Subversion Repositories SmartDukaan

Rev

Rev 5874 | Rev 6019 | 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 
 
5593 mandeep.dh 1262 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1263 
    """
1264 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1265 
    invoked while scanning IN of items.
5553 rajveer 1266 
 
5593 mandeep.dh 1267 
    Parameters:
1268 
     - itemId
1269 
     - quantity
1270 
     - fulfilmentWarehouseId
1271 
     - billingWarehouseId
1272 
    """
1273 
    pass
1274 
 
6000 mandeep.dh 1275 
  def createRechargeOrder(self, rechargeOrder):
1276 
    """
1277 
    Parameters:
1278 
     - rechargeOrder
1279 
    """
1280 
    pass
5593 mandeep.dh 1281 
 
6000 mandeep.dh 1282 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1283 
    """
1284 
    Parameters:
1285 
     - rechargeOrderId
1286 
     - rechargeOrderStatus
1287 
    """
1288 
    pass
1289 
 
1290 
  def activateRechargeTxn(self, rechargeCoupons):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeCoupons
1294 
    """
1295 
    pass
1296 
 
1297 
  def getRechargeOrders(self, customerId):
1298 
    """
1299 
    Parameters:
1300 
     - customerId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeCoupons(self, customerId, rechargeCouponStatus):
1305 
    """
1306 
    Parameters:
1307 
     - customerId
1308 
     - rechargeCouponStatus
1309 
    """
1310 
    pass
1311 
 
1312 
 
3376 rajveer 1313 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1314 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1315 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1316 
 
1317 
  def createTransaction(self, transaction):
1318 
    """
1319 
    Parameters:
1320 
     - transaction
1321 
    """
1322 
    self.send_createTransaction(transaction)
132 ashish 1323 
    return self.recv_createTransaction()
94 ashish 1324 
 
1325 
  def send_createTransaction(self, transaction):
1326 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1327 
    args = createTransaction_args()
1328 
    args.transaction = transaction
1329 
    args.write(self._oprot)
1330 
    self._oprot.writeMessageEnd()
1331 
    self._oprot.trans.flush()
1332 
 
1333 
  def recv_createTransaction(self, ):
1334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1335 
    if mtype == TMessageType.EXCEPTION:
1336 
      x = TApplicationException()
1337 
      x.read(self._iprot)
1338 
      self._iprot.readMessageEnd()
1339 
      raise x
1340 
    result = createTransaction_result()
1341 
    result.read(self._iprot)
1342 
    self._iprot.readMessageEnd()
3431 rajveer 1343 
    if result.success is not None:
132 ashish 1344 
      return result.success
3431 rajveer 1345 
    if result.ex is not None:
94 ashish 1346 
      raise result.ex
132 ashish 1347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1348 
 
1349 
  def getTransaction(self, id):
1350 
    """
1351 
    Parameters:
1352 
     - id
1353 
    """
1354 
    self.send_getTransaction(id)
1355 
    return self.recv_getTransaction()
1356 
 
1357 
  def send_getTransaction(self, id):
1358 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1359 
    args = getTransaction_args()
1360 
    args.id = id
1361 
    args.write(self._oprot)
1362 
    self._oprot.writeMessageEnd()
1363 
    self._oprot.trans.flush()
1364 
 
1365 
  def recv_getTransaction(self, ):
1366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1367 
    if mtype == TMessageType.EXCEPTION:
1368 
      x = TApplicationException()
1369 
      x.read(self._iprot)
1370 
      self._iprot.readMessageEnd()
1371 
      raise x
1372 
    result = getTransaction_result()
1373 
    result.read(self._iprot)
1374 
    self._iprot.readMessageEnd()
3431 rajveer 1375 
    if result.success is not None:
94 ashish 1376 
      return result.success
3431 rajveer 1377 
    if result.ex is not None:
94 ashish 1378 
      raise result.ex
1379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1380 
 
1381 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1382 
    """
1383 
    Parameters:
1384 
     - customerId
1385 
     - from_date
1386 
     - to_date
1387 
     - status
1388 
    """
1389 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1390 
    return self.recv_getTransactionsForCustomer()
1391 
 
1392 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1393 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1394 
    args = getTransactionsForCustomer_args()
1395 
    args.customerId = customerId
1396 
    args.from_date = from_date
1397 
    args.to_date = to_date
1398 
    args.status = status
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getTransactionsForCustomer(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getTransactionsForCustomer_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
94 ashish 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
94 ashish 1416 
      raise result.ex
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1418 
 
132 ashish 1419 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1420 
    """
1421 
    Parameters:
1422 
     - shoppingCartId
1423 
    """
1424 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1425 
    return self.recv_getTransactionsForShoppingCartId()
1426 
 
1427 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1428 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1429 
    args = getTransactionsForShoppingCartId_args()
1430 
    args.shoppingCartId = shoppingCartId
1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
1435 
  def recv_getTransactionsForShoppingCartId(self, ):
1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
1442 
    result = getTransactionsForShoppingCartId_result()
1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
3431 rajveer 1445 
    if result.success is not None:
132 ashish 1446 
      return result.success
3431 rajveer 1447 
    if result.ex is not None:
132 ashish 1448 
      raise result.ex
1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1450 
 
94 ashish 1451 
  def getTransactionStatus(self, transactionId):
1452 
    """
1453 
    Parameters:
1454 
     - transactionId
1455 
    """
1456 
    self.send_getTransactionStatus(transactionId)
1457 
    return self.recv_getTransactionStatus()
1458 
 
1459 
  def send_getTransactionStatus(self, transactionId):
1460 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1461 
    args = getTransactionStatus_args()
1462 
    args.transactionId = transactionId
1463 
    args.write(self._oprot)
1464 
    self._oprot.writeMessageEnd()
1465 
    self._oprot.trans.flush()
1466 
 
1467 
  def recv_getTransactionStatus(self, ):
1468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1469 
    if mtype == TMessageType.EXCEPTION:
1470 
      x = TApplicationException()
1471 
      x.read(self._iprot)
1472 
      self._iprot.readMessageEnd()
1473 
      raise x
1474 
    result = getTransactionStatus_result()
1475 
    result.read(self._iprot)
1476 
    self._iprot.readMessageEnd()
3431 rajveer 1477 
    if result.success is not None:
94 ashish 1478 
      return result.success
3431 rajveer 1479 
    if result.ex is not None:
94 ashish 1480 
      raise result.ex
1481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1482 
 
5527 anupam.sin 1483 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1484 
    """
1485 
    Parameters:
1486 
     - transactionId
1487 
     - status
1488 
     - description
5527 anupam.sin 1489 
     - pickUp
1490 
     - orderType
94 ashish 1491 
    """
5527 anupam.sin 1492 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1493 
    return self.recv_changeTransactionStatus()
1494 
 
5527 anupam.sin 1495 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1496 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1497 
    args = changeTransactionStatus_args()
1498 
    args.transactionId = transactionId
1499 
    args.status = status
1500 
    args.description = description
5527 anupam.sin 1501 
    args.pickUp = pickUp
1502 
    args.orderType = orderType
94 ashish 1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_changeTransactionStatus(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = changeTransactionStatus_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
3431 rajveer 1517 
    if result.success is not None:
94 ashish 1518 
      return result.success
3431 rajveer 1519 
    if result.ex is not None:
94 ashish 1520 
      raise result.ex
1521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1522 
 
1398 varun.gupt 1523 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1524 
    """
1525 
    Parameters:
1526 
     - transactionId
1527 
    """
1398 varun.gupt 1528 
    self.send_enqueueTransactionInfoEmail(transactionId)
1529 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1530 
 
1398 varun.gupt 1531 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1532 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1533 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1534 
    args.transactionId = transactionId
1535 
    args.write(self._oprot)
1536 
    self._oprot.writeMessageEnd()
1537 
    self._oprot.trans.flush()
1538 
 
1398 varun.gupt 1539 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1541 
    if mtype == TMessageType.EXCEPTION:
1542 
      x = TApplicationException()
1543 
      x.read(self._iprot)
1544 
      self._iprot.readMessageEnd()
1545 
      raise x
1398 varun.gupt 1546 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1547 
    result.read(self._iprot)
1548 
    self._iprot.readMessageEnd()
3431 rajveer 1549 
    if result.success is not None:
1382 varun.gupt 1550 
      return result.success
3431 rajveer 1551 
    if result.ex is not None:
1382 varun.gupt 1552 
      raise result.ex
1398 varun.gupt 1553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1554 
 
4801 anupam.sin 1555 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1556 
    """
1557 
    Parameters:
4801 anupam.sin 1558 
     - statuses
483 rajveer 1559 
     - from_date
1560 
     - to_date
1561 
     - warehouse_id
94 ashish 1562 
    """
4801 anupam.sin 1563 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1564 
    return self.recv_getAllOrders()
94 ashish 1565 
 
4801 anupam.sin 1566 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1567 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1568 
    args = getAllOrders_args()
4801 anupam.sin 1569 
    args.statuses = statuses
483 rajveer 1570 
    args.from_date = from_date
1571 
    args.to_date = to_date
1572 
    args.warehouse_id = warehouse_id
94 ashish 1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
483 rajveer 1577 
  def recv_getAllOrders(self, ):
94 ashish 1578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1579 
    if mtype == TMessageType.EXCEPTION:
1580 
      x = TApplicationException()
1581 
      x.read(self._iprot)
1582 
      self._iprot.readMessageEnd()
1583 
      raise x
483 rajveer 1584 
    result = getAllOrders_result()
94 ashish 1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
3431 rajveer 1587 
    if result.success is not None:
94 ashish 1588 
      return result.success
3431 rajveer 1589 
    if result.ex is not None:
94 ashish 1590 
      raise result.ex
483 rajveer 1591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1592 
 
4133 chandransh 1593 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1594 
    """
1595 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1596 
    Pass the status as null and the limit as 0 to ignore them.
1597 
 
1598 
    Parameters:
1599 
     - statuses
1600 
     - offset
1601 
     - limit
1602 
     - warehouse_id
1603 
    """
1604 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1605 
    return self.recv_getOrdersInBatch()
1606 
 
1607 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1608 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1609 
    args = getOrdersInBatch_args()
1610 
    args.statuses = statuses
1611 
    args.offset = offset
1612 
    args.limit = limit
1613 
    args.warehouse_id = warehouse_id
1614 
    args.write(self._oprot)
1615 
    self._oprot.writeMessageEnd()
1616 
    self._oprot.trans.flush()
1617 
 
1618 
  def recv_getOrdersInBatch(self, ):
1619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1620 
    if mtype == TMessageType.EXCEPTION:
1621 
      x = TApplicationException()
1622 
      x.read(self._iprot)
1623 
      self._iprot.readMessageEnd()
1624 
      raise x
1625 
    result = getOrdersInBatch_result()
1626 
    result.read(self._iprot)
1627 
    self._iprot.readMessageEnd()
1628 
    if result.success is not None:
1629 
      return result.success
1630 
    if result.ex is not None:
1631 
      raise result.ex
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1633 
 
1634 
  def getOrderCount(self, statuses, warehouseId):
1635 
    """
1636 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1637 
 
1638 
    Parameters:
1639 
     - statuses
1640 
     - warehouseId
1641 
    """
1642 
    self.send_getOrderCount(statuses, warehouseId)
1643 
    return self.recv_getOrderCount()
1644 
 
1645 
  def send_getOrderCount(self, statuses, warehouseId):
1646 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1647 
    args = getOrderCount_args()
1648 
    args.statuses = statuses
1649 
    args.warehouseId = warehouseId
1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1654 
  def recv_getOrderCount(self, ):
1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1661 
    result = getOrderCount_result()
1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
1664 
    if result.success is not None:
1665 
      return result.success
1666 
    if result.ex is not None:
1667 
      raise result.ex
1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1669 
 
999 varun.gupt 1670 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1671 
    """
1132 chandransh 1672 
    Returns orders within a range of their billing dates
3431 rajveer 1673 
 
999 varun.gupt 1674 
    Parameters:
1675 
     - status
1676 
     - start_billing_date
1677 
     - end_billing_date
1678 
     - warehouse_id
1679 
    """
1680 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1681 
    return self.recv_getOrdersByBillingDate()
1682 
 
1683 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1684 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1685 
    args = getOrdersByBillingDate_args()
1686 
    args.status = status
1687 
    args.start_billing_date = start_billing_date
1688 
    args.end_billing_date = end_billing_date
1689 
    args.warehouse_id = warehouse_id
1690 
    args.write(self._oprot)
1691 
    self._oprot.writeMessageEnd()
1692 
    self._oprot.trans.flush()
1693 
 
1694 
  def recv_getOrdersByBillingDate(self, ):
1695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1696 
    if mtype == TMessageType.EXCEPTION:
1697 
      x = TApplicationException()
1698 
      x.read(self._iprot)
1699 
      self._iprot.readMessageEnd()
1700 
      raise x
1701 
    result = getOrdersByBillingDate_result()
1702 
    result.read(self._iprot)
1703 
    self._iprot.readMessageEnd()
3431 rajveer 1704 
    if result.success is not None:
999 varun.gupt 1705 
      return result.success
3431 rajveer 1706 
    if result.ex is not None:
999 varun.gupt 1707 
      raise result.ex
1708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1709 
 
3451 chandransh 1710 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1711 
    """
1712 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1713 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1714 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1715 
 
3427 chandransh 1716 
    Parameters:
1717 
     - fromShippingDate
1718 
     - toShippingDate
1719 
     - providerId
1720 
     - warehouseId
3451 chandransh 1721 
     - cod
3427 chandransh 1722 
    """
3451 chandransh 1723 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1724 
    return self.recv_getOrdersByShippingDate()
1725 
 
3451 chandransh 1726 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1727 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1728 
    args = getOrdersByShippingDate_args()
1729 
    args.fromShippingDate = fromShippingDate
1730 
    args.toShippingDate = toShippingDate
1731 
    args.providerId = providerId
1732 
    args.warehouseId = warehouseId
3451 chandransh 1733 
    args.cod = cod
3427 chandransh 1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_getOrdersByShippingDate(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = getOrdersByShippingDate_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
3431 rajveer 1748 
    if result.success is not None:
3427 chandransh 1749 
      return result.success
3431 rajveer 1750 
    if result.ex is not None:
3427 chandransh 1751 
      raise result.ex
1752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1753 
 
1382 varun.gupt 1754 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1755 
    """
1756 
    Returns order ids for orders which can be returned
3431 rajveer 1757 
 
1382 varun.gupt 1758 
    Parameters:
1759 
     - customer_id
1760 
     - limit
1761 
    """
1762 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1763 
    return self.recv_getReturnableOrdersForCustomer()
1764 
 
1765 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1766 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1767 
    args = getReturnableOrdersForCustomer_args()
1768 
    args.customer_id = customer_id
1769 
    args.limit = limit
1770 
    args.write(self._oprot)
1771 
    self._oprot.writeMessageEnd()
1772 
    self._oprot.trans.flush()
1773 
 
1774 
  def recv_getReturnableOrdersForCustomer(self, ):
1775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1776 
    if mtype == TMessageType.EXCEPTION:
1777 
      x = TApplicationException()
1778 
      x.read(self._iprot)
1779 
      self._iprot.readMessageEnd()
1780 
      raise x
1781 
    result = getReturnableOrdersForCustomer_result()
1782 
    result.read(self._iprot)
1783 
    self._iprot.readMessageEnd()
3431 rajveer 1784 
    if result.success is not None:
1382 varun.gupt 1785 
      return result.success
3431 rajveer 1786 
    if result.ex is not None:
1382 varun.gupt 1787 
      raise result.ex
1788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1789 
 
1790 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1791 
    """
1792 
    Returns order ids for orders which can be cancelled
3431 rajveer 1793 
 
1382 varun.gupt 1794 
    Parameters:
1795 
     - customer_id
1796 
     - limit
1797 
    """
1798 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1799 
    return self.recv_getCancellableOrdersForCustomer()
1800 
 
1801 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1802 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1803 
    args = getCancellableOrdersForCustomer_args()
1804 
    args.customer_id = customer_id
1805 
    args.limit = limit
1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
1810 
  def recv_getCancellableOrdersForCustomer(self, ):
1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
1817 
    result = getCancellableOrdersForCustomer_result()
1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
3431 rajveer 1820 
    if result.success is not None:
1382 varun.gupt 1821 
      return result.success
3431 rajveer 1822 
    if result.ex is not None:
1382 varun.gupt 1823 
      raise result.ex
1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1825 
 
483 rajveer 1826 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1827 
    """
1828 
    Parameters:
483 rajveer 1829 
     - orderId
1830 
     - status
1831 
     - description
94 ashish 1832 
    """
483 rajveer 1833 
    self.send_changeOrderStatus(orderId, status, description)
1834 
    return self.recv_changeOrderStatus()
94 ashish 1835 
 
483 rajveer 1836 
  def send_changeOrderStatus(self, orderId, status, description):
1837 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1838 
    args = changeOrderStatus_args()
1839 
    args.orderId = orderId
1840 
    args.status = status
1841 
    args.description = description
94 ashish 1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
483 rajveer 1846 
  def recv_changeOrderStatus(self, ):
94 ashish 1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
483 rajveer 1853 
    result = changeOrderStatus_result()
94 ashish 1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
3431 rajveer 1856 
    if result.success is not None:
94 ashish 1857 
      return result.success
3431 rajveer 1858 
    if result.ex is not None:
94 ashish 1859 
      raise result.ex
483 rajveer 1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1861 
 
1528 ankur.sing 1862 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1863 
    """
1528 ankur.sing 1864 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1865 
    only user who owns the transaction can view its order details.
3431 rajveer 1866 
 
94 ashish 1867 
    Parameters:
1868 
     - transactionId
1528 ankur.sing 1869 
     - customerId
94 ashish 1870 
    """
1528 ankur.sing 1871 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1872 
    return self.recv_getOrdersForTransaction()
94 ashish 1873 
 
1528 ankur.sing 1874 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1875 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1876 
    args = getOrdersForTransaction_args()
94 ashish 1877 
    args.transactionId = transactionId
1528 ankur.sing 1878 
    args.customerId = customerId
94 ashish 1879 
    args.write(self._oprot)
1880 
    self._oprot.writeMessageEnd()
1881 
    self._oprot.trans.flush()
1882 
 
483 rajveer 1883 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1885 
    if mtype == TMessageType.EXCEPTION:
1886 
      x = TApplicationException()
1887 
      x.read(self._iprot)
1888 
      self._iprot.readMessageEnd()
1889 
      raise x
483 rajveer 1890 
    result = getOrdersForTransaction_result()
94 ashish 1891 
    result.read(self._iprot)
1892 
    self._iprot.readMessageEnd()
3431 rajveer 1893 
    if result.success is not None:
94 ashish 1894 
      return result.success
3431 rajveer 1895 
    if result.ex is not None:
94 ashish 1896 
      raise result.ex
483 rajveer 1897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1898 
 
3014 chandransh 1899 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1900 
    """
3014 chandransh 1901 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1902 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1903 
 
94 ashish 1904 
    Parameters:
483 rajveer 1905 
     - customerId
1906 
     - from_date
1907 
     - to_date
3014 chandransh 1908 
     - statuses
94 ashish 1909 
    """
3014 chandransh 1910 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1911 
    return self.recv_getOrdersForCustomer()
94 ashish 1912 
 
3014 chandransh 1913 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1914 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1915 
    args = getOrdersForCustomer_args()
1916 
    args.customerId = customerId
1917 
    args.from_date = from_date
1918 
    args.to_date = to_date
3014 chandransh 1919 
    args.statuses = statuses
94 ashish 1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
483 rajveer 1924 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
483 rajveer 1931 
    result = getOrdersForCustomer_result()
94 ashish 1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
3431 rajveer 1934 
    if result.success is not None:
94 ashish 1935 
      return result.success
3431 rajveer 1936 
    if result.ex is not None:
94 ashish 1937 
      raise result.ex
483 rajveer 1938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1939 
 
483 rajveer 1940 
  def createOrder(self, order):
94 ashish 1941 
    """
1942 
    Parameters:
483 rajveer 1943 
     - order
94 ashish 1944 
    """
483 rajveer 1945 
    self.send_createOrder(order)
1946 
    return self.recv_createOrder()
94 ashish 1947 
 
483 rajveer 1948 
  def send_createOrder(self, order):
1949 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1950 
    args = createOrder_args()
1951 
    args.order = order
94 ashish 1952 
    args.write(self._oprot)
1953 
    self._oprot.writeMessageEnd()
1954 
    self._oprot.trans.flush()
1955 
 
483 rajveer 1956 
  def recv_createOrder(self, ):
94 ashish 1957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1958 
    if mtype == TMessageType.EXCEPTION:
1959 
      x = TApplicationException()
1960 
      x.read(self._iprot)
1961 
      self._iprot.readMessageEnd()
1962 
      raise x
483 rajveer 1963 
    result = createOrder_result()
94 ashish 1964 
    result.read(self._iprot)
1965 
    self._iprot.readMessageEnd()
3431 rajveer 1966 
    if result.success is not None:
94 ashish 1967 
      return result.success
3431 rajveer 1968 
    if result.ex is not None:
94 ashish 1969 
      raise result.ex
483 rajveer 1970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1971 
 
483 rajveer 1972 
  def getOrder(self, id):
94 ashish 1973 
    """
1974 
    Parameters:
483 rajveer 1975 
     - id
94 ashish 1976 
    """
483 rajveer 1977 
    self.send_getOrder(id)
1978 
    return self.recv_getOrder()
94 ashish 1979 
 
483 rajveer 1980 
  def send_getOrder(self, id):
1981 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1982 
    args = getOrder_args()
1983 
    args.id = id
94 ashish 1984 
    args.write(self._oprot)
1985 
    self._oprot.writeMessageEnd()
1986 
    self._oprot.trans.flush()
1987 
 
483 rajveer 1988 
  def recv_getOrder(self, ):
94 ashish 1989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1990 
    if mtype == TMessageType.EXCEPTION:
1991 
      x = TApplicationException()
1992 
      x.read(self._iprot)
1993 
      self._iprot.readMessageEnd()
1994 
      raise x
483 rajveer 1995 
    result = getOrder_result()
94 ashish 1996 
    result.read(self._iprot)
1997 
    self._iprot.readMessageEnd()
3431 rajveer 1998 
    if result.success is not None:
94 ashish 1999 
      return result.success
3431 rajveer 2000 
    if result.ex is not None:
94 ashish 2001 
      raise result.ex
483 rajveer 2002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2003 
 
483 rajveer 2004 
  def getLineItemsForOrder(self, orderId):
94 ashish 2005 
    """
2006 
    Parameters:
483 rajveer 2007 
     - orderId
94 ashish 2008 
    """
483 rajveer 2009 
    self.send_getLineItemsForOrder(orderId)
2010 
    return self.recv_getLineItemsForOrder()
94 ashish 2011 
 
483 rajveer 2012 
  def send_getLineItemsForOrder(self, orderId):
2013 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2014 
    args = getLineItemsForOrder_args()
2015 
    args.orderId = orderId
94 ashish 2016 
    args.write(self._oprot)
2017 
    self._oprot.writeMessageEnd()
2018 
    self._oprot.trans.flush()
2019 
 
483 rajveer 2020 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2022 
    if mtype == TMessageType.EXCEPTION:
2023 
      x = TApplicationException()
2024 
      x.read(self._iprot)
2025 
      self._iprot.readMessageEnd()
2026 
      raise x
483 rajveer 2027 
    result = getLineItemsForOrder_result()
94 ashish 2028 
    result.read(self._iprot)
2029 
    self._iprot.readMessageEnd()
3431 rajveer 2030 
    if result.success is not None:
94 ashish 2031 
      return result.success
3431 rajveer 2032 
    if result.ex is not None:
94 ashish 2033 
      raise result.ex
483 rajveer 2034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2035 
 
4999 phani.kuma 2036 
  def getOrderList(self, order_ids):
2037 
    """
2038 
    Parameters:
2039 
     - order_ids
2040 
    """
2041 
    self.send_getOrderList(order_ids)
2042 
    return self.recv_getOrderList()
2043 
 
2044 
  def send_getOrderList(self, order_ids):
2045 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2046 
    args = getOrderList_args()
2047 
    args.order_ids = order_ids
2048 
    args.write(self._oprot)
2049 
    self._oprot.writeMessageEnd()
2050 
    self._oprot.trans.flush()
2051 
 
2052 
  def recv_getOrderList(self, ):
2053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2054 
    if mtype == TMessageType.EXCEPTION:
2055 
      x = TApplicationException()
2056 
      x.read(self._iprot)
2057 
      self._iprot.readMessageEnd()
2058 
      raise x
2059 
    result = getOrderList_result()
2060 
    result.read(self._iprot)
2061 
    self._iprot.readMessageEnd()
2062 
    if result.success is not None:
2063 
      return result.success
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2065 
 
5386 phani.kuma 2066 
  def getOrderListForVendor(self, order_ids, vendorId):
2067 
    """
2068 
    Parameters:
2069 
     - order_ids
2070 
     - vendorId
2071 
    """
2072 
    self.send_getOrderListForVendor(order_ids, vendorId)
2073 
    return self.recv_getOrderListForVendor()
2074 
 
2075 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2076 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2077 
    args = getOrderListForVendor_args()
2078 
    args.order_ids = order_ids
2079 
    args.vendorId = vendorId
2080 
    args.write(self._oprot)
2081 
    self._oprot.writeMessageEnd()
2082 
    self._oprot.trans.flush()
2083 
 
2084 
  def recv_getOrderListForVendor(self, ):
2085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2086 
    if mtype == TMessageType.EXCEPTION:
2087 
      x = TApplicationException()
2088 
      x.read(self._iprot)
2089 
      self._iprot.readMessageEnd()
2090 
      raise x
2091 
    result = getOrderListForVendor_result()
2092 
    result.read(self._iprot)
2093 
    self._iprot.readMessageEnd()
2094 
    if result.success is not None:
2095 
      return result.success
2096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2097 
 
1528 ankur.sing 2098 
  def getOrderForCustomer(self, orderId, customerId):
2099 
    """
2100 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2101 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2102 
 
1528 ankur.sing 2103 
    Parameters:
2104 
     - orderId
2105 
     - customerId
2106 
    """
2107 
    self.send_getOrderForCustomer(orderId, customerId)
2108 
    return self.recv_getOrderForCustomer()
2109 
 
2110 
  def send_getOrderForCustomer(self, orderId, customerId):
2111 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2112 
    args = getOrderForCustomer_args()
2113 
    args.orderId = orderId
2114 
    args.customerId = customerId
2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
2119 
  def recv_getOrderForCustomer(self, ):
2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
2126 
    result = getOrderForCustomer_result()
2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
1528 ankur.sing 2130 
      return result.success
3431 rajveer 2131 
    if result.ex is not None:
1528 ankur.sing 2132 
      raise result.ex
2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2134 
 
4444 rajveer 2135 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2136 
    """
2137 
    Parameters:
4394 rajveer 2138 
     - type
4444 rajveer 2139 
     - warehouseId
4394 rajveer 2140 
     - status
2141 
     - timestamp
3064 chandransh 2142 
    """
4444 rajveer 2143 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2144 
    return self.recv_getAlerts()
2145 
 
4444 rajveer 2146 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2147 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2148 
    args = getAlerts_args()
4394 rajveer 2149 
    args.type = type
4444 rajveer 2150 
    args.warehouseId = warehouseId
4394 rajveer 2151 
    args.status = status
2152 
    args.timestamp = timestamp
3064 chandransh 2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_getAlerts(self, ):
2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
2164 
    result = getAlerts_result()
2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
3431 rajveer 2167 
    if result.success is not None:
3064 chandransh 2168 
      return result.success
2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2170 
 
4444 rajveer 2171 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2172 
    """
2173 
    Parameters:
2174 
     - type
4444 rajveer 2175 
     - warehouseId
4394 rajveer 2176 
     - description
3064 chandransh 2177 
    """
4444 rajveer 2178 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2179 
    self.recv_addAlert()
3064 chandransh 2180 
 
4444 rajveer 2181 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2182 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2183 
    args = addAlert_args()
3064 chandransh 2184 
    args.type = type
4444 rajveer 2185 
    args.warehouseId = warehouseId
4394 rajveer 2186 
    args.description = description
3064 chandransh 2187 
    args.write(self._oprot)
2188 
    self._oprot.writeMessageEnd()
2189 
    self._oprot.trans.flush()
2190 
 
4394 rajveer 2191 
  def recv_addAlert(self, ):
3064 chandransh 2192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2193 
    if mtype == TMessageType.EXCEPTION:
2194 
      x = TApplicationException()
2195 
      x.read(self._iprot)
2196 
      self._iprot.readMessageEnd()
2197 
      raise x
4394 rajveer 2198 
    result = addAlert_result()
3064 chandransh 2199 
    result.read(self._iprot)
2200 
    self._iprot.readMessageEnd()
2201 
    return
2202 
 
4444 rajveer 2203 
  def markAlertsAsSeen(self, warehouseId):
2204 
    """
2205 
    Parameters:
2206 
     - warehouseId
2207 
    """
2208 
    self.send_markAlertsAsSeen(warehouseId)
2209 
    self.recv_markAlertsAsSeen()
2210 
 
2211 
  def send_markAlertsAsSeen(self, warehouseId):
2212 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2213 
    args = markAlertsAsSeen_args()
2214 
    args.warehouseId = warehouseId
2215 
    args.write(self._oprot)
2216 
    self._oprot.writeMessageEnd()
2217 
    self._oprot.trans.flush()
2218 
 
2219 
  def recv_markAlertsAsSeen(self, ):
2220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2221 
    if mtype == TMessageType.EXCEPTION:
2222 
      x = TApplicationException()
2223 
      x.read(self._iprot)
2224 
      self._iprot.readMessageEnd()
2225 
      raise x
2226 
    result = markAlertsAsSeen_result()
2227 
    result.read(self._iprot)
2228 
    self._iprot.readMessageEnd()
2229 
    return
2230 
 
3064 chandransh 2231 
  def getValidOrderCount(self, ):
2232 
    """
2233 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2234 
    """
2235 
    self.send_getValidOrderCount()
2236 
    return self.recv_getValidOrderCount()
2237 
 
2238 
  def send_getValidOrderCount(self, ):
2239 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2240 
    args = getValidOrderCount_args()
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_getValidOrderCount(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = getValidOrderCount_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.success is not None:
3064 chandransh 2256 
      return result.success
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2258 
 
2259 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2260 
    """
2261 
    Returns the number of distinct customers who have done successful transactions
2262 
    """
2263 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2264 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2265 
 
2266 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2267 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2268 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2269 
    args.write(self._oprot)
2270 
    self._oprot.writeMessageEnd()
2271 
    self._oprot.trans.flush()
2272 
 
2273 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2275 
    if mtype == TMessageType.EXCEPTION:
2276 
      x = TApplicationException()
2277 
      x.read(self._iprot)
2278 
      self._iprot.readMessageEnd()
2279 
      raise x
2280 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2281 
    result.read(self._iprot)
2282 
    self._iprot.readMessageEnd()
3431 rajveer 2283 
    if result.success is not None:
3064 chandransh 2284 
      return result.success
2285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2286 
 
2287 
  def getValidOrdersAmountRange(self, ):
2288 
    """
2289 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2290 
    List contains two values, first minimum amount and second maximum amount.
2291 
    """
2292 
    self.send_getValidOrdersAmountRange()
2293 
    return self.recv_getValidOrdersAmountRange()
2294 
 
2295 
  def send_getValidOrdersAmountRange(self, ):
2296 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2297 
    args = getValidOrdersAmountRange_args()
2298 
    args.write(self._oprot)
2299 
    self._oprot.writeMessageEnd()
2300 
    self._oprot.trans.flush()
2301 
 
2302 
  def recv_getValidOrdersAmountRange(self, ):
2303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2304 
    if mtype == TMessageType.EXCEPTION:
2305 
      x = TApplicationException()
2306 
      x.read(self._iprot)
2307 
      self._iprot.readMessageEnd()
2308 
      raise x
2309 
    result = getValidOrdersAmountRange_result()
2310 
    result.read(self._iprot)
2311 
    self._iprot.readMessageEnd()
3431 rajveer 2312 
    if result.success is not None:
3064 chandransh 2313 
      return result.success
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2315 
 
5874 rajveer 2316 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2317 
    """
2318 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2319 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2320 
 
3064 chandransh 2321 
    Parameters:
2322 
     - limit
5874 rajveer 2323 
     - onlyStore
3064 chandransh 2324 
    """
5874 rajveer 2325 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2326 
    return self.recv_getValidOrders()
2327 
 
5874 rajveer 2328 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2329 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2330 
    args = getValidOrders_args()
2331 
    args.limit = limit
5874 rajveer 2332 
    args.onlyStore = onlyStore
3064 chandransh 2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_getValidOrders(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = getValidOrders_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
3431 rajveer 2347 
    if result.success is not None:
3064 chandransh 2348 
      return result.success
2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2350 
 
1220 chandransh 2351 
  def batchOrders(self, warehouseId):
2352 
    """
2353 
    Create a batch of all the pending orders for the given warehouse.
2354 
    The returned list is orderd by created_timestamp.
2355 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2356 
 
1220 chandransh 2357 
    Parameters:
2358 
     - warehouseId
2359 
    """
2360 
    self.send_batchOrders(warehouseId)
2361 
    return self.recv_batchOrders()
2362 
 
2363 
  def send_batchOrders(self, warehouseId):
2364 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2365 
    args = batchOrders_args()
2366 
    args.warehouseId = warehouseId
2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
2371 
  def recv_batchOrders(self, ):
2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
2378 
    result = batchOrders_result()
2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
3431 rajveer 2381 
    if result.success is not None:
1220 chandransh 2382 
      return result.success
3431 rajveer 2383 
    if result.ex is not None:
1220 chandransh 2384 
      raise result.ex
2385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2386 
 
1208 chandransh 2387 
  def markOrderAsOutOfStock(self, orderId):
2388 
    """
2389 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2390 
 
1208 chandransh 2391 
    Parameters:
2392 
     - orderId
2393 
    """
2394 
    self.send_markOrderAsOutOfStock(orderId)
2395 
    return self.recv_markOrderAsOutOfStock()
2396 
 
2397 
  def send_markOrderAsOutOfStock(self, orderId):
2398 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2399 
    args = markOrderAsOutOfStock_args()
2400 
    args.orderId = orderId
2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_markOrderAsOutOfStock(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 = markOrderAsOutOfStock_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
3431 rajveer 2415 
    if result.success is not None:
1208 chandransh 2416 
      return result.success
3431 rajveer 2417 
    if result.ex is not None:
1208 chandransh 2418 
      raise result.ex
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2420 
 
3064 chandransh 2421 
  def verifyOrder(self, orderId):
759 chandransh 2422 
    """
3064 chandransh 2423 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2424 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2425 
    used for all other orders as well.
2426 
    Throws an exception if no such order exists.
3431 rajveer 2427 
 
759 chandransh 2428 
    Parameters:
3064 chandransh 2429 
     - orderId
759 chandransh 2430 
    """
3064 chandransh 2431 
    self.send_verifyOrder(orderId)
2432 
    return self.recv_verifyOrder()
759 chandransh 2433 
 
3064 chandransh 2434 
  def send_verifyOrder(self, orderId):
2435 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2436 
    args = verifyOrder_args()
2437 
    args.orderId = orderId
759 chandransh 2438 
    args.write(self._oprot)
2439 
    self._oprot.writeMessageEnd()
2440 
    self._oprot.trans.flush()
2441 
 
3064 chandransh 2442 
  def recv_verifyOrder(self, ):
759 chandransh 2443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2444 
    if mtype == TMessageType.EXCEPTION:
2445 
      x = TApplicationException()
2446 
      x.read(self._iprot)
2447 
      self._iprot.readMessageEnd()
2448 
      raise x
3064 chandransh 2449 
    result = verifyOrder_result()
759 chandransh 2450 
    result.read(self._iprot)
2451 
    self._iprot.readMessageEnd()
3431 rajveer 2452 
    if result.success is not None:
759 chandransh 2453 
      return result.success
3431 rajveer 2454 
    if result.ex is not None:
759 chandransh 2455 
      raise result.ex
3064 chandransh 2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2457 
 
3064 chandransh 2458 
  def acceptOrder(self, orderId):
1113 chandransh 2459 
    """
3064 chandransh 2460 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2461 
    given order is not a COD order, it also captures the payment if the same has
2462 
    not been captured.
2463 
    Throws an exception if no such order exists.
3431 rajveer 2464 
 
1113 chandransh 2465 
    Parameters:
3064 chandransh 2466 
     - orderId
1113 chandransh 2467 
    """
3064 chandransh 2468 
    self.send_acceptOrder(orderId)
2469 
    return self.recv_acceptOrder()
1113 chandransh 2470 
 
3064 chandransh 2471 
  def send_acceptOrder(self, orderId):
2472 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2473 
    args = acceptOrder_args()
2474 
    args.orderId = orderId
1113 chandransh 2475 
    args.write(self._oprot)
2476 
    self._oprot.writeMessageEnd()
2477 
    self._oprot.trans.flush()
2478 
 
3064 chandransh 2479 
  def recv_acceptOrder(self, ):
1113 chandransh 2480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2481 
    if mtype == TMessageType.EXCEPTION:
2482 
      x = TApplicationException()
2483 
      x.read(self._iprot)
2484 
      self._iprot.readMessageEnd()
2485 
      raise x
3064 chandransh 2486 
    result = acceptOrder_result()
1113 chandransh 2487 
    result.read(self._iprot)
2488 
    self._iprot.readMessageEnd()
3431 rajveer 2489 
    if result.success is not None:
1113 chandransh 2490 
      return result.success
3431 rajveer 2491 
    if result.ex is not None:
1113 chandransh 2492 
      raise result.ex
3064 chandransh 2493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2494 
 
5110 mandeep.dh 2495 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2496 
    """
3064 chandransh 2497 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2498 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2499 
    the IMEI no. if a -1 is supplied.
2500 
    Also, it generates an invoice number for the order, marks the order as
2501 
    BILLED and sets the billing timestamp.
2502 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2503 
 
1135 chandransh 2504 
    Parameters:
3064 chandransh 2505 
     - orderId
2506 
     - invoice_number
4658 mandeep.dh 2507 
     - serialNumber
4283 anupam.sin 2508 
     - itemNumber
3064 chandransh 2509 
     - billed_by
4264 rajveer 2510 
     - jacketNumber
4283 anupam.sin 2511 
     - billingType
5110 mandeep.dh 2512 
     - fulfilmentWarehouseId
4763 rajveer 2513 
     - authorize
1135 chandransh 2514 
    """
5110 mandeep.dh 2515 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2516 
    return self.recv_addBillingDetails()
1135 chandransh 2517 
 
5110 mandeep.dh 2518 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2519 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2520 
    args = addBillingDetails_args()
2521 
    args.orderId = orderId
2522 
    args.invoice_number = invoice_number
4658 mandeep.dh 2523 
    args.serialNumber = serialNumber
4283 anupam.sin 2524 
    args.itemNumber = itemNumber
3064 chandransh 2525 
    args.billed_by = billed_by
4264 rajveer 2526 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2527 
    args.billingType = billingType
5110 mandeep.dh 2528 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2529 
    args.authorize = authorize
1135 chandransh 2530 
    args.write(self._oprot)
2531 
    self._oprot.writeMessageEnd()
2532 
    self._oprot.trans.flush()
2533 
 
3064 chandransh 2534 
  def recv_addBillingDetails(self, ):
1135 chandransh 2535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2536 
    if mtype == TMessageType.EXCEPTION:
2537 
      x = TApplicationException()
2538 
      x.read(self._iprot)
2539 
      self._iprot.readMessageEnd()
2540 
      raise x
3064 chandransh 2541 
    result = addBillingDetails_result()
1135 chandransh 2542 
    result.read(self._iprot)
2543 
    self._iprot.readMessageEnd()
3431 rajveer 2544 
    if result.success is not None:
3064 chandransh 2545 
      return result.success
3431 rajveer 2546 
    if result.ex is not None:
1135 chandransh 2547 
      raise result.ex
3064 chandransh 2548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2549 
 
4763 rajveer 2550 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2551 
    """
2552 
    Add the invoice number to the order.
2553 
 
2554 
    Parameters:
2555 
     - orderId
2556 
     - invoiceNumber
4763 rajveer 2557 
     - color
4579 rajveer 2558 
    """
4763 rajveer 2559 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2560 
    self.recv_addInvoiceNumber()
2561 
 
4763 rajveer 2562 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2563 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2564 
    args = addInvoiceNumber_args()
2565 
    args.orderId = orderId
2566 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2567 
    args.color = color
4579 rajveer 2568 
    args.write(self._oprot)
2569 
    self._oprot.writeMessageEnd()
2570 
    self._oprot.trans.flush()
2571 
 
2572 
  def recv_addInvoiceNumber(self, ):
2573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2574 
    if mtype == TMessageType.EXCEPTION:
2575 
      x = TApplicationException()
2576 
      x.read(self._iprot)
2577 
      self._iprot.readMessageEnd()
2578 
      raise x
2579 
    result = addInvoiceNumber_result()
2580 
    result.read(self._iprot)
2581 
    self._iprot.readMessageEnd()
2582 
    if result.ex is not None:
2583 
      raise result.ex
2584 
    return
2585 
 
4910 phani.kuma 2586 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2587 
    """
3064 chandransh 2588 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2589 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2590 
 
1408 ankur.sing 2591 
    Parameters:
3064 chandransh 2592 
     - warehouseId
1408 ankur.sing 2593 
     - providerId
3064 chandransh 2594 
     - cod
4910 phani.kuma 2595 
     - orderIds
1408 ankur.sing 2596 
    """
4910 phani.kuma 2597 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2598 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2599 
 
4910 phani.kuma 2600 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2601 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2602 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2603 
    args.warehouseId = warehouseId
1408 ankur.sing 2604 
    args.providerId = providerId
3064 chandransh 2605 
    args.cod = cod
4910 phani.kuma 2606 
    args.orderIds = orderIds
1408 ankur.sing 2607 
    args.write(self._oprot)
2608 
    self._oprot.writeMessageEnd()
2609 
    self._oprot.trans.flush()
2610 
 
4910 phani.kuma 2611 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2613 
    if mtype == TMessageType.EXCEPTION:
2614 
      x = TApplicationException()
2615 
      x.read(self._iprot)
2616 
      self._iprot.readMessageEnd()
2617 
      raise x
4910 phani.kuma 2618 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2619 
    result.read(self._iprot)
2620 
    self._iprot.readMessageEnd()
3431 rajveer 2621 
    if result.success is not None:
1408 ankur.sing 2622 
      return result.success
3431 rajveer 2623 
    if result.ex is not None:
3064 chandransh 2624 
      raise result.ex
4910 phani.kuma 2625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2626 
 
5713 rajveer 2627 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2628 
    """
2629 
    Parameters:
2630 
     - providerId
2631 
     - orderIds
5713 rajveer 2632 
     - awbs
5676 rajveer 2633 
    """
5713 rajveer 2634 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2635 
    return self.recv_markOrdersAsReturnedFromStore()
2636 
 
5713 rajveer 2637 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2638 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2639 
    args = markOrdersAsReturnedFromStore_args()
2640 
    args.providerId = providerId
2641 
    args.orderIds = orderIds
5713 rajveer 2642 
    args.awbs = awbs
5676 rajveer 2643 
    args.write(self._oprot)
2644 
    self._oprot.writeMessageEnd()
2645 
    self._oprot.trans.flush()
2646 
 
2647 
  def recv_markOrdersAsReturnedFromStore(self, ):
2648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2649 
    if mtype == TMessageType.EXCEPTION:
2650 
      x = TApplicationException()
2651 
      x.read(self._iprot)
2652 
      self._iprot.readMessageEnd()
2653 
      raise x
2654 
    result = markOrdersAsReturnedFromStore_result()
2655 
    result.read(self._iprot)
2656 
    self._iprot.readMessageEnd()
2657 
    if result.success is not None:
2658 
      return result.success
2659 
    if result.ex is not None:
2660 
      raise result.ex
2661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2662 
 
4910 phani.kuma 2663 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2664 
    """
4910 phani.kuma 2665 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2666 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2667 
 
2668 
    Parameters:
2669 
     - providerId
4910 phani.kuma 2670 
     - pickupDetails
4410 rajveer 2671 
    """
4910 phani.kuma 2672 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2673 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2674 
 
4910 phani.kuma 2675 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2676 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2677 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2678 
    args.providerId = providerId
4910 phani.kuma 2679 
    args.pickupDetails = pickupDetails
4410 rajveer 2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
4910 phani.kuma 2684 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
4910 phani.kuma 2691 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.ex is not None:
2695 
      raise result.ex
4910 phani.kuma 2696 
    return
4410 rajveer 2697 
 
4910 phani.kuma 2698 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2699 
    """
3064 chandransh 2700 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2701 
 
94 ashish 2702 
    Parameters:
3064 chandransh 2703 
     - providerId
304 ashish 2704 
    """
4910 phani.kuma 2705 
    self.send_getOrdersNotPickedUp(providerId)
2706 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2707 
 
4910 phani.kuma 2708 
  def send_getOrdersNotPickedUp(self, providerId):
2709 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2710 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2711 
    args.providerId = providerId
304 ashish 2712 
    args.write(self._oprot)
2713 
    self._oprot.writeMessageEnd()
2714 
    self._oprot.trans.flush()
2715 
 
4910 phani.kuma 2716 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2718 
    if mtype == TMessageType.EXCEPTION:
2719 
      x = TApplicationException()
2720 
      x.read(self._iprot)
2721 
      self._iprot.readMessageEnd()
2722 
      raise x
4910 phani.kuma 2723 
    result = getOrdersNotPickedUp_result()
304 ashish 2724 
    result.read(self._iprot)
2725 
    self._iprot.readMessageEnd()
3431 rajveer 2726 
    if result.success is not None:
304 ashish 2727 
      return result.success
4910 phani.kuma 2728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2729 
 
3064 chandransh 2730 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2731 
    """
3064 chandransh 2732 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2733 
    the name of the receiver.
2734 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2735 
 
304 ashish 2736 
    Parameters:
3064 chandransh 2737 
     - providerId
2738 
     - deliveredOrders
304 ashish 2739 
    """
3064 chandransh 2740 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2741 
    self.recv_markOrdersAsDelivered()
304 ashish 2742 
 
3064 chandransh 2743 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2744 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2745 
    args = markOrdersAsDelivered_args()
2746 
    args.providerId = providerId
2747 
    args.deliveredOrders = deliveredOrders
304 ashish 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
3064 chandransh 2752 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 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
3064 chandransh 2759 
    result = markOrdersAsDelivered_result()
304 ashish 2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
3431 rajveer 2762 
    if result.ex is not None:
3064 chandransh 2763 
      raise result.ex
304 ashish 2764 
    return
2765 
 
4910 phani.kuma 2766 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2767 
    """
4910 phani.kuma 2768 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2769 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2770 
 
3064 chandransh 2771 
    Parameters:
2772 
     - providerId
2773 
     - returnedOrders
1596 ankur.sing 2774 
    """
4910 phani.kuma 2775 
    self.send_markAsRTOrders(providerId, returnedOrders)
2776 
    self.recv_markAsRTOrders()
304 ashish 2777 
 
4910 phani.kuma 2778 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2779 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2780 
    args = markAsRTOrders_args()
3064 chandransh 2781 
    args.providerId = providerId
2782 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
4910 phani.kuma 2787 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2789 
    if mtype == TMessageType.EXCEPTION:
2790 
      x = TApplicationException()
2791 
      x.read(self._iprot)
2792 
      self._iprot.readMessageEnd()
2793 
      raise x
4910 phani.kuma 2794 
    result = markAsRTOrders_result()
1596 ankur.sing 2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
3431 rajveer 2797 
    if result.ex is not None:
3064 chandransh 2798 
      raise result.ex
2799 
    return
1596 ankur.sing 2800 
 
4910 phani.kuma 2801 
  def getRTOrders(self, providerId):
2802 
    """
2803 
    Returns a list of orders that were returned by courier.
2804 
 
2805 
    Parameters:
2806 
     - providerId
2807 
    """
2808 
    self.send_getRTOrders(providerId)
2809 
    return self.recv_getRTOrders()
2810 
 
2811 
  def send_getRTOrders(self, providerId):
2812 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2813 
    args = getRTOrders_args()
2814 
    args.providerId = providerId
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_getRTOrders(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = getRTOrders_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
2829 
    if result.success is not None:
2830 
      return result.success
2831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2832 
 
3064 chandransh 2833 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2834 
    """
3064 chandransh 2835 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2836 
 
3064 chandransh 2837 
    Parameters:
2838 
     - providerId
2839 
     - undeliveredOrders
1627 ankur.sing 2840 
    """
3064 chandransh 2841 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2842 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2843 
 
3064 chandransh 2844 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2845 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2846 
    args = updateNonDeliveryReason_args()
2847 
    args.providerId = providerId
2848 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2849 
    args.write(self._oprot)
2850 
    self._oprot.writeMessageEnd()
2851 
    self._oprot.trans.flush()
2852 
 
3064 chandransh 2853 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2855 
    if mtype == TMessageType.EXCEPTION:
2856 
      x = TApplicationException()
2857 
      x.read(self._iprot)
2858 
      self._iprot.readMessageEnd()
2859 
      raise x
3064 chandransh 2860 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2861 
    result.read(self._iprot)
2862 
    self._iprot.readMessageEnd()
4910 phani.kuma 2863 
    if result.ex is not None:
2864 
      raise result.ex
2865 
    return
2866 
 
2867 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2868 
    """
2869 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2870 
 
2871 
    Parameters:
2872 
     - providerId
2873 
    """
2874 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2875 
    return self.recv_getNonDeliveredOrdersbyCourier()
2876 
 
2877 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2878 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2879 
    args = getNonDeliveredOrdersbyCourier_args()
2880 
    args.providerId = providerId
2881 
    args.write(self._oprot)
2882 
    self._oprot.writeMessageEnd()
2883 
    self._oprot.trans.flush()
2884 
 
2885 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2887 
    if mtype == TMessageType.EXCEPTION:
2888 
      x = TApplicationException()
2889 
      x.read(self._iprot)
2890 
      self._iprot.readMessageEnd()
2891 
      raise x
2892 
    result = getNonDeliveredOrdersbyCourier_result()
2893 
    result.read(self._iprot)
2894 
    self._iprot.readMessageEnd()
4581 phani.kuma 2895 
    if result.success is not None:
2896 
      return result.success
4910 phani.kuma 2897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2898 
 
2899 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2900 
    """
2901 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2902 
 
2903 
    Parameters:
2904 
     - providerId
2905 
     - local_connected_orders
2906 
    """
2907 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2908 
    self.recv_markOrdersAsLocalConnected()
2909 
 
2910 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2911 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2912 
    args = markOrdersAsLocalConnected_args()
2913 
    args.providerId = providerId
2914 
    args.local_connected_orders = local_connected_orders
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_markOrdersAsLocalConnected(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = markOrdersAsLocalConnected_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
3431 rajveer 2929 
    if result.ex is not None:
3064 chandransh 2930 
      raise result.ex
4910 phani.kuma 2931 
    return
1627 ankur.sing 2932 
 
4910 phani.kuma 2933 
  def getOrdersNotLocalConnected(self, providerId):
2934 
    """
2935 
    Returns a list of orders that were picked up or shipped but pending local connection.
2936 
 
2937 
    Parameters:
2938 
     - providerId
2939 
    """
2940 
    self.send_getOrdersNotLocalConnected(providerId)
2941 
    return self.recv_getOrdersNotLocalConnected()
2942 
 
2943 
  def send_getOrdersNotLocalConnected(self, providerId):
2944 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2945 
    args = getOrdersNotLocalConnected_args()
2946 
    args.providerId = providerId
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_getOrdersNotLocalConnected(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = getOrdersNotLocalConnected_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
2961 
    if result.success is not None:
2962 
      return result.success
2963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2964 
 
2965 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2966 
    """
2967 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2968 
 
2969 
    Parameters:
2970 
     - providerId
2971 
     - destination_city_reached_orders
2972 
    """
2973 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2974 
    self.recv_markOrdersAsDestinationCityReached()
2975 
 
2976 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2977 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2978 
    args = markOrdersAsDestinationCityReached_args()
2979 
    args.providerId = providerId
2980 
    args.destination_city_reached_orders = destination_city_reached_orders
2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_markOrdersAsDestinationCityReached(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = markOrdersAsDestinationCityReached_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
2995 
    if result.ex is not None:
2996 
      raise result.ex
2997 
    return
2998 
 
2999 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3000 
    """
3001 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3002 
 
3003 
    Parameters:
3004 
     - providerId
3005 
     - first_atdl_orders
3006 
    """
3007 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3008 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3009 
 
3010 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3011 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3012 
    args = markOrdersAsFirstDeliveryAttempted_args()
3013 
    args.providerId = providerId
3014 
    args.first_atdl_orders = first_atdl_orders
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_markOrdersAsFirstDeliveryAttempted(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 = markOrdersAsFirstDeliveryAttempted_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.ex is not None:
3030 
      raise result.ex
3031 
    return
3032 
 
3064 chandransh 3033 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3034 
    """
3064 chandransh 3035 
    Returns the list of orders whose delivery time has passed but have not been
3036 
    delivered yet for the given provider and warehouse. To get a complete list of
3037 
    undelivered orders, pass them as -1.
3038 
    Returns an empty list if no such orders exist.
3431 rajveer 3039 
 
1886 ankur.sing 3040 
    Parameters:
3064 chandransh 3041 
     - providerId
3042 
     - warehouseId
1886 ankur.sing 3043 
    """
3064 chandransh 3044 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3045 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3046 
 
3064 chandransh 3047 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3048 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3049 
    args = getUndeliveredOrders_args()
3050 
    args.providerId = providerId
3051 
    args.warehouseId = warehouseId
1886 ankur.sing 3052 
    args.write(self._oprot)
3053 
    self._oprot.writeMessageEnd()
3054 
    self._oprot.trans.flush()
3055 
 
3064 chandransh 3056 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3058 
    if mtype == TMessageType.EXCEPTION:
3059 
      x = TApplicationException()
3060 
      x.read(self._iprot)
3061 
      self._iprot.readMessageEnd()
3062 
      raise x
3064 chandransh 3063 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3064 
    result.read(self._iprot)
3065 
    self._iprot.readMessageEnd()
3431 rajveer 3066 
    if result.success is not None:
1886 ankur.sing 3067 
      return result.success
3064 chandransh 3068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3069 
 
4783 phani.kuma 3070 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3071 
    """
3072 
    Returns the list of orders whose expected delivery date has passed but have not been
3073 
    delivered yet.
3074 
    Returns an empty list if no such orders exist.
3075 
    """
3076 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3077 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3078 
 
3079 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3080 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3081 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3096 
    if result.success is not None:
3097 
      return result.success
3098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3099 
 
2536 chandransh 3100 
  def toggleDOAFlag(self, orderId):
3101 
    """
3102 
    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.
3103 
    Returns the final flag status.
3104 
    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 3105 
 
2536 chandransh 3106 
    Parameters:
3107 
     - orderId
3108 
    """
3109 
    self.send_toggleDOAFlag(orderId)
3110 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3111 
 
2536 chandransh 3112 
  def send_toggleDOAFlag(self, orderId):
3113 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3114 
    args = toggleDOAFlag_args()
3115 
    args.orderId = orderId
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_toggleDOAFlag(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = toggleDOAFlag_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3431 rajveer 3130 
    if result.success is not None:
2536 chandransh 3131 
      return result.success
3431 rajveer 3132 
    if result.ex is not None:
2536 chandransh 3133 
      raise result.ex
3134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3135 
 
4712 rajveer 3136 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3137 
    """
3138 
    Parameters:
3139 
     - orderId
3140 
     - deliveryTimestamp
3141 
     - receiver
3142 
    """
3143 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3144 
    self.recv_markOrderAsDelivered()
3145 
 
3146 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3147 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3148 
    args = markOrderAsDelivered_args()
3149 
    args.orderId = orderId
3150 
    args.deliveryTimestamp = deliveryTimestamp
3151 
    args.receiver = receiver
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
3156 
  def recv_markOrderAsDelivered(self, ):
3157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3158 
    if mtype == TMessageType.EXCEPTION:
3159 
      x = TApplicationException()
3160 
      x.read(self._iprot)
3161 
      self._iprot.readMessageEnd()
3162 
      raise x
3163 
    result = markOrderAsDelivered_result()
3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.ex is not None:
3167 
      raise result.ex
3168 
    return
3169 
 
5553 rajveer 3170 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3171 
    """
3172 
    Parameters:
3173 
     - orderId
3174 
     - deliveryTimestamp
3175 
    """
3176 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3177 
    self.recv_markOrderAsReceivedAtStore()
3178 
 
3179 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3180 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3181 
    args = markOrderAsReceivedAtStore_args()
3182 
    args.orderId = orderId
3183 
    args.deliveryTimestamp = deliveryTimestamp
3184 
    args.write(self._oprot)
3185 
    self._oprot.writeMessageEnd()
3186 
    self._oprot.trans.flush()
3187 
 
3188 
  def recv_markOrderAsReceivedAtStore(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 = markOrderAsReceivedAtStore_result()
3196 
    result.read(self._iprot)
3197 
    self._iprot.readMessageEnd()
3198 
    if result.ex is not None:
3199 
      raise result.ex
3200 
    return
3201 
 
4454 rajveer 3202 
  def markOrderDoaRequestReceived(self, orderId):
3203 
    """
3204 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3205 
 
3206 
    Parameters:
3207 
     - orderId
3208 
    """
3209 
    self.send_markOrderDoaRequestReceived(orderId)
3210 
    return self.recv_markOrderDoaRequestReceived()
3211 
 
3212 
  def send_markOrderDoaRequestReceived(self, orderId):
3213 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3214 
    args = markOrderDoaRequestReceived_args()
3215 
    args.orderId = orderId
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_markOrderDoaRequestReceived(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = markOrderDoaRequestReceived_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
3230 
    if result.success is not None:
3231 
      return result.success
3232 
    if result.ex is not None:
3233 
      raise result.ex
3234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3235 
 
3236 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3237 
    """
3238 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3239 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3240 
 
3241 
    Parameters:
3242 
     - orderId
3243 
     - isAuthorized
3244 
    """
3245 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3246 
    return self.recv_markOrderDoaRequestAuthorized()
3247 
 
3248 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3249 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3250 
    args = markOrderDoaRequestAuthorized_args()
3251 
    args.orderId = orderId
3252 
    args.isAuthorized = isAuthorized
3253 
    args.write(self._oprot)
3254 
    self._oprot.writeMessageEnd()
3255 
    self._oprot.trans.flush()
3256 
 
3257 
  def recv_markOrderDoaRequestAuthorized(self, ):
3258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3259 
    if mtype == TMessageType.EXCEPTION:
3260 
      x = TApplicationException()
3261 
      x.read(self._iprot)
3262 
      self._iprot.readMessageEnd()
3263 
      raise x
3264 
    result = markOrderDoaRequestAuthorized_result()
3265 
    result.read(self._iprot)
3266 
    self._iprot.readMessageEnd()
3267 
    if result.success is not None:
3268 
      return result.success
3269 
    if result.ex is not None:
3270 
      raise result.ex
3271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3272 
 
4488 rajveer 3273 
  def markOrderReturnRequestReceived(self, orderId):
3274 
    """
3275 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3276 
 
3277 
    Parameters:
3278 
     - orderId
3279 
    """
3280 
    self.send_markOrderReturnRequestReceived(orderId)
3281 
    return self.recv_markOrderReturnRequestReceived()
3282 
 
3283 
  def send_markOrderReturnRequestReceived(self, orderId):
3284 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3285 
    args = markOrderReturnRequestReceived_args()
3286 
    args.orderId = orderId
3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
3291 
  def recv_markOrderReturnRequestReceived(self, ):
3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
3298 
    result = markOrderReturnRequestReceived_result()
3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3301 
    if result.success is not None:
3302 
      return result.success
3303 
    if result.ex is not None:
3304 
      raise result.ex
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3306 
 
3307 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3308 
    """
3309 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3310 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3311 
 
3312 
    Parameters:
3313 
     - orderId
3314 
     - isAuthorized
3315 
    """
3316 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3317 
    return self.recv_markOrderReturnRequestAuthorized()
3318 
 
3319 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3320 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3321 
    args = markOrderReturnRequestAuthorized_args()
3322 
    args.orderId = orderId
3323 
    args.isAuthorized = isAuthorized
3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_markOrderReturnRequestAuthorized(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = markOrderReturnRequestAuthorized_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3338 
    if result.success is not None:
3339 
      return result.success
3340 
    if result.ex is not None:
3341 
      raise result.ex
3342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3343 
 
4579 rajveer 3344 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3345 
    """
3346 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3347 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3348 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3349 
    For any other status, it returns false.
3350 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3351 
 
2536 chandransh 3352 
    Parameters:
3353 
     - orderId
4579 rajveer 3354 
     - providerId
2536 chandransh 3355 
    """
4579 rajveer 3356 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3357 
    return self.recv_requestPickupNumber()
3358 
 
4579 rajveer 3359 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3360 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3361 
    args = requestPickupNumber_args()
3362 
    args.orderId = orderId
4579 rajveer 3363 
    args.providerId = providerId
2536 chandransh 3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_requestPickupNumber(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = requestPickupNumber_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3431 rajveer 3378 
    if result.success is not None:
2536 chandransh 3379 
      return result.success
3431 rajveer 3380 
    if result.ex is not None:
2536 chandransh 3381 
      raise result.ex
3382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3383 
 
4602 rajveer 3384 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3385 
    """
4452 rajveer 3386 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3387 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3388 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3389 
    	3. Returns true
2591 chandransh 3390 
    If the order is in any other status, it returns false.
2536 chandransh 3391 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3392 
 
2536 chandransh 3393 
    Parameters:
3394 
     - orderId
3395 
     - pickupNumber
4602 rajveer 3396 
     - providerId
2536 chandransh 3397 
    """
4602 rajveer 3398 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3399 
    return self.recv_authorizePickup()
3400 
 
4602 rajveer 3401 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3402 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3403 
    args = authorizePickup_args()
3404 
    args.orderId = orderId
3405 
    args.pickupNumber = pickupNumber
4602 rajveer 3406 
    args.providerId = providerId
2536 chandransh 3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_authorizePickup(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = authorizePickup_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3431 rajveer 3421 
    if result.success is not None:
2536 chandransh 3422 
      return result.success
3431 rajveer 3423 
    if result.ex is not None:
2536 chandransh 3424 
      raise result.ex
3425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3426 
 
2764 chandransh 3427 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3428 
    """
3429 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3430 
 
2764 chandransh 3431 
    Parameters:
3432 
     - providerId
3433 
     - pickupDetails
3434 
    """
3435 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3436 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3437 
 
3438 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3439 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3440 
    args = markDoasAsPickedUp_args()
3441 
    args.providerId = providerId
3442 
    args.pickupDetails = pickupDetails
3443 
    args.write(self._oprot)
3444 
    self._oprot.writeMessageEnd()
3445 
    self._oprot.trans.flush()
3446 
 
3447 
  def recv_markDoasAsPickedUp(self, ):
3448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3449 
    if mtype == TMessageType.EXCEPTION:
3450 
      x = TApplicationException()
3451 
      x.read(self._iprot)
3452 
      self._iprot.readMessageEnd()
3453 
      raise x
3454 
    result = markDoasAsPickedUp_result()
3455 
    result.read(self._iprot)
3456 
    self._iprot.readMessageEnd()
4910 phani.kuma 3457 
    return
3458 
 
3459 
  def getDoasNotPickedUp(self, providerId):
3460 
    """
3461 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3462 
 
3463 
    Parameters:
3464 
     - providerId
3465 
    """
3466 
    self.send_getDoasNotPickedUp(providerId)
3467 
    return self.recv_getDoasNotPickedUp()
3468 
 
3469 
  def send_getDoasNotPickedUp(self, providerId):
3470 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3471 
    args = getDoasNotPickedUp_args()
3472 
    args.providerId = providerId
3473 
    args.write(self._oprot)
3474 
    self._oprot.writeMessageEnd()
3475 
    self._oprot.trans.flush()
3476 
 
3477 
  def recv_getDoasNotPickedUp(self, ):
3478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3479 
    if mtype == TMessageType.EXCEPTION:
3480 
      x = TApplicationException()
3481 
      x.read(self._iprot)
3482 
      self._iprot.readMessageEnd()
3483 
      raise x
3484 
    result = getDoasNotPickedUp_result()
3485 
    result.read(self._iprot)
3486 
    self._iprot.readMessageEnd()
3431 rajveer 3487 
    if result.success is not None:
2764 chandransh 3488 
      return result.success
4910 phani.kuma 3489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3490 
 
4741 phani.kuma 3491 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3492 
    """
3493 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3494 
 
3495 
    Parameters:
3496 
     - providerId
3497 
     - pickupDetails
3498 
    """
3499 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3500 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3501 
 
3502 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3503 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3504 
    args = markReturnOrdersAsPickedUp_args()
3505 
    args.providerId = providerId
3506 
    args.pickupDetails = pickupDetails
3507 
    args.write(self._oprot)
3508 
    self._oprot.writeMessageEnd()
3509 
    self._oprot.trans.flush()
3510 
 
3511 
  def recv_markReturnOrdersAsPickedUp(self, ):
3512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3513 
    if mtype == TMessageType.EXCEPTION:
3514 
      x = TApplicationException()
3515 
      x.read(self._iprot)
3516 
      self._iprot.readMessageEnd()
3517 
      raise x
3518 
    result = markReturnOrdersAsPickedUp_result()
3519 
    result.read(self._iprot)
3520 
    self._iprot.readMessageEnd()
4910 phani.kuma 3521 
    return
3522 
 
3523 
  def getReturnOrdersNotPickedUp(self, providerId):
3524 
    """
3525 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3526 
 
3527 
    Parameters:
3528 
     - providerId
3529 
    """
3530 
    self.send_getReturnOrdersNotPickedUp(providerId)
3531 
    return self.recv_getReturnOrdersNotPickedUp()
3532 
 
3533 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3534 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3535 
    args = getReturnOrdersNotPickedUp_args()
3536 
    args.providerId = providerId
3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
3541 
  def recv_getReturnOrdersNotPickedUp(self, ):
3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
3548 
    result = getReturnOrdersNotPickedUp_result()
3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
4741 phani.kuma 3551 
    if result.success is not None:
3552 
      return result.success
4910 phani.kuma 3553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3554 
 
4479 rajveer 3555 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3556 
    """
4452 rajveer 3557 
    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 3558 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3559 
    If the order is in any other state, it returns false.
3560 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3561 
 
2591 chandransh 3562 
    Parameters:
3563 
     - orderId
4479 rajveer 3564 
     - receiveCondition
2591 chandransh 3565 
    """
4479 rajveer 3566 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3567 
    return self.recv_receiveReturn()
2536 chandransh 3568 
 
4479 rajveer 3569 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3570 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3571 
    args = receiveReturn_args()
2591 chandransh 3572 
    args.orderId = orderId
4479 rajveer 3573 
    args.receiveCondition = receiveCondition
2591 chandransh 3574 
    args.write(self._oprot)
3575 
    self._oprot.writeMessageEnd()
3576 
    self._oprot.trans.flush()
3577 
 
2616 chandransh 3578 
  def recv_receiveReturn(self, ):
2591 chandransh 3579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3580 
    if mtype == TMessageType.EXCEPTION:
3581 
      x = TApplicationException()
3582 
      x.read(self._iprot)
3583 
      self._iprot.readMessageEnd()
3584 
      raise x
2616 chandransh 3585 
    result = receiveReturn_result()
2591 chandransh 3586 
    result.read(self._iprot)
3587 
    self._iprot.readMessageEnd()
3431 rajveer 3588 
    if result.success is not None:
2591 chandransh 3589 
      return result.success
3431 rajveer 3590 
    if result.ex is not None:
2591 chandransh 3591 
      raise result.ex
2616 chandransh 3592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3593 
 
3594 
  def validateDoa(self, orderId, isValid):
3595 
    """
4452 rajveer 3596 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3597 
    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 3598 
    If the order is in any other state, it returns false.
3599 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3600 
 
2591 chandransh 3601 
    Parameters:
3602 
     - orderId
3603 
     - isValid
3604 
    """
3605 
    self.send_validateDoa(orderId, isValid)
3606 
    return self.recv_validateDoa()
3607 
 
3608 
  def send_validateDoa(self, orderId, isValid):
3609 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3610 
    args = validateDoa_args()
3611 
    args.orderId = orderId
3612 
    args.isValid = isValid
3613 
    args.write(self._oprot)
3614 
    self._oprot.writeMessageEnd()
3615 
    self._oprot.trans.flush()
3616 
 
3617 
  def recv_validateDoa(self, ):
3618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3619 
    if mtype == TMessageType.EXCEPTION:
3620 
      x = TApplicationException()
3621 
      x.read(self._iprot)
3622 
      self._iprot.readMessageEnd()
3623 
      raise x
3624 
    result = validateDoa_result()
3625 
    result.read(self._iprot)
3626 
    self._iprot.readMessageEnd()
3431 rajveer 3627 
    if result.success is not None:
2591 chandransh 3628 
      return result.success
3431 rajveer 3629 
    if result.ex is not None:
2591 chandransh 3630 
      raise result.ex
3631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3632 
 
4495 rajveer 3633 
  def validateReturnProduct(self, orderId, isUsable):
3634 
    """
3635 
    Parameters:
3636 
     - orderId
3637 
     - isUsable
3638 
    """
3639 
    self.send_validateReturnProduct(orderId, isUsable)
3640 
    return self.recv_validateReturnProduct()
3641 
 
3642 
  def send_validateReturnProduct(self, orderId, isUsable):
3643 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3644 
    args = validateReturnProduct_args()
3645 
    args.orderId = orderId
3646 
    args.isUsable = isUsable
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_validateReturnProduct(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = validateReturnProduct_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
3661 
    if result.success is not None:
3662 
      return result.success
3663 
    if result.ex is not None:
3664 
      raise result.ex
3665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3666 
 
2616 chandransh 3667 
  def reshipOrder(self, orderId):
3668 
    """
4484 rajveer 3669 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3670 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3671 
    	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 3672 
 
3673 
    If the order is in DOA_CERT_VALID state, it does the following:
3674 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3675 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3676 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3677 
 
2616 chandransh 3678 
    Returns the id of the newly created order.
3431 rajveer 3679 
 
2616 chandransh 3680 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3681 
 
2616 chandransh 3682 
    Parameters:
3683 
     - orderId
3684 
    """
3685 
    self.send_reshipOrder(orderId)
3686 
    return self.recv_reshipOrder()
2591 chandransh 3687 
 
2616 chandransh 3688 
  def send_reshipOrder(self, orderId):
3689 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3690 
    args = reshipOrder_args()
3691 
    args.orderId = orderId
3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_reshipOrder(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = reshipOrder_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
3431 rajveer 3706 
    if result.success is not None:
2616 chandransh 3707 
      return result.success
3431 rajveer 3708 
    if result.ex is not None:
2616 chandransh 3709 
      raise result.ex
3710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3711 
 
3226 chandransh 3712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3713 
    """
4484 rajveer 3714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3715 
    	1. Creates a refund request for batch processing.
3716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3718 
 
2616 chandransh 3719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3720 
    	1. Creates a refund request for batch processing.
3226 chandransh 3721 
    	2. Cancels the reservation of the item in the warehouse.
3722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3723 
 
3226 chandransh 3724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3725 
    	1. Cancels the reservation of the item in the warehouse.
3726 
    	2. Marks the current order as CANCELED.
3727 
 
3728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3729 
 
2616 chandransh 3730 
    Returns True if it is successful, False otherwise.
3431 rajveer 3731 
 
2616 chandransh 3732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3733 
 
2616 chandransh 3734 
    Parameters:
3735 
     - orderId
3226 chandransh 3736 
     - refundedBy
3737 
     - reason
2616 chandransh 3738 
    """
3226 chandransh 3739 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3740 
    return self.recv_refundOrder()
3741 
 
3226 chandransh 3742 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3743 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3744 
    args = refundOrder_args()
3745 
    args.orderId = orderId
3226 chandransh 3746 
    args.refundedBy = refundedBy
3747 
    args.reason = reason
2616 chandransh 3748 
    args.write(self._oprot)
3749 
    self._oprot.writeMessageEnd()
3750 
    self._oprot.trans.flush()
3751 
 
3752 
  def recv_refundOrder(self, ):
3753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3754 
    if mtype == TMessageType.EXCEPTION:
3755 
      x = TApplicationException()
3756 
      x.read(self._iprot)
3757 
      self._iprot.readMessageEnd()
3758 
      raise x
3759 
    result = refundOrder_result()
3760 
    result.read(self._iprot)
3761 
    self._iprot.readMessageEnd()
3431 rajveer 3762 
    if result.success is not None:
2616 chandransh 3763 
      return result.success
3431 rajveer 3764 
    if result.ex is not None:
2616 chandransh 3765 
      raise result.ex
3766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3767 
 
2690 chandransh 3768 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3769 
    """
3770 
    Get all return orders created between the from and to dates for the given warehouse.
3771 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3772 
 
2690 chandransh 3773 
    Parameters:
3774 
     - warehouseId
3775 
     - fromDate
3776 
     - toDate
3777 
    """
3778 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3779 
    return self.recv_getReturnOrders()
2616 chandransh 3780 
 
2690 chandransh 3781 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3782 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3783 
    args = getReturnOrders_args()
3784 
    args.warehouseId = warehouseId
3785 
    args.fromDate = fromDate
3786 
    args.toDate = toDate
3787 
    args.write(self._oprot)
3788 
    self._oprot.writeMessageEnd()
3789 
    self._oprot.trans.flush()
3790 
 
3791 
  def recv_getReturnOrders(self, ):
3792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3793 
    if mtype == TMessageType.EXCEPTION:
3794 
      x = TApplicationException()
3795 
      x.read(self._iprot)
3796 
      self._iprot.readMessageEnd()
3797 
      raise x
3798 
    result = getReturnOrders_result()
3799 
    result.read(self._iprot)
3800 
    self._iprot.readMessageEnd()
3431 rajveer 3801 
    if result.success is not None:
2690 chandransh 3802 
      return result.success
3803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3804 
 
5481 phani.kuma 3805 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3806 
    """
3807 
    Get all return orders created between the from and to dates.
3808 
 
3809 
    Parameters:
3810 
     - onlyNotProcessed
3811 
     - fromDate
3812 
     - toDate
3813 
    """
3814 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3815 
    return self.recv_getAllReturnOrders()
3816 
 
3817 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3818 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3819 
    args = getAllReturnOrders_args()
3820 
    args.onlyNotProcessed = onlyNotProcessed
3821 
    args.fromDate = fromDate
3822 
    args.toDate = toDate
3823 
    args.write(self._oprot)
3824 
    self._oprot.writeMessageEnd()
3825 
    self._oprot.trans.flush()
3826 
 
3827 
  def recv_getAllReturnOrders(self, ):
3828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3829 
    if mtype == TMessageType.EXCEPTION:
3830 
      x = TApplicationException()
3831 
      x.read(self._iprot)
3832 
      self._iprot.readMessageEnd()
3833 
      raise x
3834 
    result = getAllReturnOrders_result()
3835 
    result.read(self._iprot)
3836 
    self._iprot.readMessageEnd()
3837 
    if result.success is not None:
3838 
      return result.success
3839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3840 
 
2700 chandransh 3841 
  def getReturnOrder(self, id):
3842 
    """
3843 
    Returns the ReturnOrder corresponding to the given id.
3844 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3845 
 
2700 chandransh 3846 
    Parameters:
3847 
     - id
3848 
    """
3849 
    self.send_getReturnOrder(id)
3850 
    return self.recv_getReturnOrder()
3851 
 
3852 
  def send_getReturnOrder(self, id):
3853 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3854 
    args = getReturnOrder_args()
3855 
    args.id = id
3856 
    args.write(self._oprot)
3857 
    self._oprot.writeMessageEnd()
3858 
    self._oprot.trans.flush()
3859 
 
3860 
  def recv_getReturnOrder(self, ):
3861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3862 
    if mtype == TMessageType.EXCEPTION:
3863 
      x = TApplicationException()
3864 
      x.read(self._iprot)
3865 
      self._iprot.readMessageEnd()
3866 
      raise x
3867 
    result = getReturnOrder_result()
3868 
    result.read(self._iprot)
3869 
    self._iprot.readMessageEnd()
3431 rajveer 3870 
    if result.success is not None:
2700 chandransh 3871 
      return result.success
3431 rajveer 3872 
    if result.ex is not None:
2700 chandransh 3873 
      raise result.ex
3874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3875 
 
2690 chandransh 3876 
  def processReturn(self, returnOrderId):
3877 
    """
3878 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3879 
 
2690 chandransh 3880 
    Parameters:
3881 
     - returnOrderId
3882 
    """
3883 
    self.send_processReturn(returnOrderId)
3884 
    self.recv_processReturn()
3885 
 
3886 
  def send_processReturn(self, returnOrderId):
3887 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3888 
    args = processReturn_args()
3889 
    args.returnOrderId = returnOrderId
3890 
    args.write(self._oprot)
3891 
    self._oprot.writeMessageEnd()
3892 
    self._oprot.trans.flush()
3893 
 
3894 
  def recv_processReturn(self, ):
3895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3896 
    if mtype == TMessageType.EXCEPTION:
3897 
      x = TApplicationException()
3898 
      x.read(self._iprot)
3899 
      self._iprot.readMessageEnd()
3900 
      raise x
3901 
    result = processReturn_result()
3902 
    result.read(self._iprot)
3903 
    self._iprot.readMessageEnd()
3431 rajveer 3904 
    if result.ex is not None:
2690 chandransh 3905 
      raise result.ex
3906 
    return
3907 
 
3451 chandransh 3908 
  def updateWeight(self, orderId, weight):
3909 
    """
3910 
    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 3911 
 
3451 chandransh 3912 
    Parameters:
3913 
     - orderId
3914 
     - weight
3915 
    """
3916 
    self.send_updateWeight(orderId, weight)
3917 
    return self.recv_updateWeight()
3918 
 
3919 
  def send_updateWeight(self, orderId, weight):
3920 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3921 
    args = updateWeight_args()
3922 
    args.orderId = orderId
3923 
    args.weight = weight
3924 
    args.write(self._oprot)
3925 
    self._oprot.writeMessageEnd()
3926 
    self._oprot.trans.flush()
3927 
 
3928 
  def recv_updateWeight(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 = updateWeight_result()
3936 
    result.read(self._iprot)
3937 
    self._iprot.readMessageEnd()
3938 
    if result.success is not None:
3939 
      return result.success
3940 
    if result.ex is not None:
3941 
      raise result.ex
3942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3943 
 
3469 chandransh 3944 
  def changeItem(self, orderId, itemId):
3945 
    """
3946 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3947 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3948 
 
3469 chandransh 3949 
    Parameters:
3950 
     - orderId
3951 
     - itemId
3952 
    """
3953 
    self.send_changeItem(orderId, itemId)
3954 
    return self.recv_changeItem()
3955 
 
3956 
  def send_changeItem(self, orderId, itemId):
3957 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3958 
    args = changeItem_args()
3959 
    args.orderId = orderId
3960 
    args.itemId = itemId
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_changeItem(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = changeItem_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3975 
    if result.success is not None:
3976 
      return result.success
3977 
    if result.ex is not None:
3978 
      raise result.ex
3979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3980 
 
3981 
  def shiftToWarehouse(self, orderId, warehouseId):
3982 
    """
3983 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3984 
 
3985 
    Parameters:
3986 
     - orderId
3987 
     - warehouseId
3988 
    """
3989 
    self.send_shiftToWarehouse(orderId, warehouseId)
3990 
    return self.recv_shiftToWarehouse()
3991 
 
3992 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3993 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3994 
    args = shiftToWarehouse_args()
3995 
    args.orderId = orderId
3996 
    args.warehouseId = warehouseId
3997 
    args.write(self._oprot)
3998 
    self._oprot.writeMessageEnd()
3999 
    self._oprot.trans.flush()
4000 
 
4001 
  def recv_shiftToWarehouse(self, ):
4002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4003 
    if mtype == TMessageType.EXCEPTION:
4004 
      x = TApplicationException()
4005 
      x.read(self._iprot)
4006 
      self._iprot.readMessageEnd()
4007 
      raise x
4008 
    result = shiftToWarehouse_result()
4009 
    result.read(self._iprot)
4010 
    self._iprot.readMessageEnd()
4011 
    if result.success is not None:
4012 
      return result.success
4013 
    if result.ex is not None:
4014 
      raise result.ex
4015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4016 
 
4647 rajveer 4017 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4018 
    """
4019 
    Adds the given delay reason to the given order.
3986 chandransh 4020 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4021 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4022 
 
3553 chandransh 4023 
    Parameters:
4024 
     - orderId
4025 
     - delayReason
3986 chandransh 4026 
     - furtherDelay
4647 rajveer 4027 
     - delayReasonText
3553 chandransh 4028 
    """
4647 rajveer 4029 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4030 
    return self.recv_addDelayReason()
4031 
 
4647 rajveer 4032 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4033 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4034 
    args = addDelayReason_args()
4035 
    args.orderId = orderId
4036 
    args.delayReason = delayReason
3986 chandransh 4037 
    args.furtherDelay = furtherDelay
4647 rajveer 4038 
    args.delayReasonText = delayReasonText
3553 chandransh 4039 
    args.write(self._oprot)
4040 
    self._oprot.writeMessageEnd()
4041 
    self._oprot.trans.flush()
4042 
 
4043 
  def recv_addDelayReason(self, ):
4044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4045 
    if mtype == TMessageType.EXCEPTION:
4046 
      x = TApplicationException()
4047 
      x.read(self._iprot)
4048 
      self._iprot.readMessageEnd()
4049 
      raise x
4050 
    result = addDelayReason_result()
4051 
    result.read(self._iprot)
4052 
    self._iprot.readMessageEnd()
4053 
    if result.success is not None:
4054 
      return result.success
4055 
    if result.ex is not None:
4056 
      raise result.ex
4057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4058 
 
3956 chandransh 4059 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4060 
    """
4061 
    Marks the COD orders with given AWB nos. as having been processed.
4062 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4063 
 
3956 chandransh 4064 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4065 
    1. There is no order corresponding to an AWB number.
4066 
    2. The captured amount for a payment exceeds the total payment.
4067 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4068 
 
4069 
    Parameters:
4070 
     - collectedAmountMap
4071 
     - xferBy
4072 
     - xferTxnId
4073 
     - xferDate
4074 
    """
4075 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4076 
    return self.recv_reconcileCodCollection()
4077 
 
4078 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4079 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4080 
    args = reconcileCodCollection_args()
4081 
    args.collectedAmountMap = collectedAmountMap
4082 
    args.xferBy = xferBy
4083 
    args.xferTxnId = xferTxnId
4084 
    args.xferDate = xferDate
4085 
    args.write(self._oprot)
4086 
    self._oprot.writeMessageEnd()
4087 
    self._oprot.trans.flush()
4088 
 
4089 
  def recv_reconcileCodCollection(self, ):
4090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4091 
    if mtype == TMessageType.EXCEPTION:
4092 
      x = TApplicationException()
4093 
      x.read(self._iprot)
4094 
      self._iprot.readMessageEnd()
4095 
      raise x
4096 
    result = reconcileCodCollection_result()
4097 
    result.read(self._iprot)
4098 
    self._iprot.readMessageEnd()
4099 
    if result.success is not None:
4100 
      return result.success
4101 
    if result.ex is not None:
4102 
      raise result.ex
4103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4104 
 
4008 mandeep.dh 4105 
  def getTransactionsRequiringExtraProcessing(self, category):
4106 
    """
4065 mandeep.dh 4107 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4108 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4109 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4110 
 
4008 mandeep.dh 4111 
    Parameters:
4112 
     - category
4113 
    """
4114 
    self.send_getTransactionsRequiringExtraProcessing(category)
4115 
    return self.recv_getTransactionsRequiringExtraProcessing()
4116 
 
4117 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4118 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4119 
    args = getTransactionsRequiringExtraProcessing_args()
4120 
    args.category = category
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = getTransactionsRequiringExtraProcessing_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.success is not None:
4136 
      return result.success
4137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4138 
 
4139 
  def markTransactionAsProcessed(self, transactionId, category):
4140 
    """
4141 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4142 
    It essentially deletes the transaction id record for a particular
4143 
    processing type category (if present) from DB.
4144 
    This is currently used by CRM application.
4008 mandeep.dh 4145 
 
4146 
    Parameters:
4147 
     - transactionId
4148 
     - category
4149 
    """
4150 
    self.send_markTransactionAsProcessed(transactionId, category)
4151 
    self.recv_markTransactionAsProcessed()
4152 
 
4153 
  def send_markTransactionAsProcessed(self, transactionId, category):
4154 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4155 
    args = markTransactionAsProcessed_args()
4156 
    args.transactionId = transactionId
4157 
    args.category = category
4158 
    args.write(self._oprot)
4159 
    self._oprot.writeMessageEnd()
4160 
    self._oprot.trans.flush()
4161 
 
4162 
  def recv_markTransactionAsProcessed(self, ):
4163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4164 
    if mtype == TMessageType.EXCEPTION:
4165 
      x = TApplicationException()
4166 
      x.read(self._iprot)
4167 
      self._iprot.readMessageEnd()
4168 
      raise x
4169 
    result = markTransactionAsProcessed_result()
4170 
    result.read(self._iprot)
4171 
    self._iprot.readMessageEnd()
4172 
    return
4173 
 
4018 chandransh 4174 
  def getItemWiseRiskyOrdersCount(self, ):
4175 
    """
4176 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4177 
    is defined as one whose shipping date is about to expire.
4178 
    """
4179 
    self.send_getItemWiseRiskyOrdersCount()
4180 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4181 
 
4018 chandransh 4182 
  def send_getItemWiseRiskyOrdersCount(self, ):
4183 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4184 
    args = getItemWiseRiskyOrdersCount_args()
4185 
    args.write(self._oprot)
4186 
    self._oprot.writeMessageEnd()
4187 
    self._oprot.trans.flush()
4188 
 
4189 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4191 
    if mtype == TMessageType.EXCEPTION:
4192 
      x = TApplicationException()
4193 
      x.read(self._iprot)
4194 
      self._iprot.readMessageEnd()
4195 
      raise x
4196 
    result = getItemWiseRiskyOrdersCount_result()
4197 
    result.read(self._iprot)
4198 
    self._iprot.readMessageEnd()
4199 
    if result.success is not None:
4200 
      return result.success
4201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4202 
 
4295 varun.gupt 4203 
  def getOrdersForItemIds(self, itemIds):
4204 
    """
4205 
    Returns a list of all orders which have items with given id
4206 
 
4207 
    Parameters:
4208 
     - itemIds
4209 
    """
4210 
    self.send_getOrdersForItemIds(itemIds)
4211 
    return self.recv_getOrdersForItemIds()
4212 
 
4213 
  def send_getOrdersForItemIds(self, itemIds):
4214 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4215 
    args = getOrdersForItemIds_args()
4216 
    args.itemIds = itemIds
4217 
    args.write(self._oprot)
4218 
    self._oprot.writeMessageEnd()
4219 
    self._oprot.trans.flush()
4220 
 
4221 
  def recv_getOrdersForItemIds(self, ):
4222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4223 
    if mtype == TMessageType.EXCEPTION:
4224 
      x = TApplicationException()
4225 
      x.read(self._iprot)
4226 
      self._iprot.readMessageEnd()
4227 
      raise x
4228 
    result = getOrdersForItemIds_result()
4229 
    result.read(self._iprot)
4230 
    self._iprot.readMessageEnd()
4231 
    if result.success is not None:
4232 
      return result.success
4233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4234 
 
4247 rajveer 4235 
  def markOrderCancellationRequestReceived(self, orderId):
4236 
    """
4237 
    Mark order as cancellation request received. If customer sends request of cancellation of
4238 
    a particular order, this method will be called. It will just change status of the order
4239 
    depending on its current status. It also records the previous status, so that we can move
4240 
    back to that status if cancellation request is denied.
4018 chandransh 4241 
 
4247 rajveer 4242 
    Parameters:
4243 
     - orderId
4244 
    """
4245 
    self.send_markOrderCancellationRequestReceived(orderId)
4246 
    self.recv_markOrderCancellationRequestReceived()
4247 
 
4248 
  def send_markOrderCancellationRequestReceived(self, orderId):
4249 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4250 
    args = markOrderCancellationRequestReceived_args()
4251 
    args.orderId = orderId
4252 
    args.write(self._oprot)
4253 
    self._oprot.writeMessageEnd()
4254 
    self._oprot.trans.flush()
4255 
 
4256 
  def recv_markOrderCancellationRequestReceived(self, ):
4257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4258 
    if mtype == TMessageType.EXCEPTION:
4259 
      x = TApplicationException()
4260 
      x.read(self._iprot)
4261 
      self._iprot.readMessageEnd()
4262 
      raise x
4263 
    result = markOrderCancellationRequestReceived_result()
4264 
    result.read(self._iprot)
4265 
    self._iprot.readMessageEnd()
4266 
    if result.ex is not None:
4267 
      raise result.ex
4268 
    return
4269 
 
4270 
  def markOrderCancellationRequestConfirmed(self, orderId):
4271 
    """
4272 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4273 
    cancellation request confirmed. After this OM will be able to cancel the order.
4274 
 
4275 
    Parameters:
4276 
     - orderId
4277 
    """
4278 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4279 
    self.recv_markOrderCancellationRequestConfirmed()
4280 
 
4281 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4282 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4283 
    args = markOrderCancellationRequestConfirmed_args()
4284 
    args.orderId = orderId
4285 
    args.write(self._oprot)
4286 
    self._oprot.writeMessageEnd()
4287 
    self._oprot.trans.flush()
4288 
 
4289 
  def recv_markOrderCancellationRequestConfirmed(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 = markOrderCancellationRequestConfirmed_result()
4297 
    result.read(self._iprot)
4298 
    self._iprot.readMessageEnd()
4299 
    if result.ex is not None:
4300 
      raise result.ex
4301 
    return
4302 
 
4303 
  def markOrderCancellationRequestDenied(self, orderId):
4304 
    """
4305 
    If we decide to not to cancel order, we will move the order ro previous status.
4306 
 
4307 
    Parameters:
4308 
     - orderId
4309 
    """
4310 
    self.send_markOrderCancellationRequestDenied(orderId)
4311 
    self.recv_markOrderCancellationRequestDenied()
4312 
 
4313 
  def send_markOrderCancellationRequestDenied(self, orderId):
4314 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4315 
    args = markOrderCancellationRequestDenied_args()
4316 
    args.orderId = orderId
4317 
    args.write(self._oprot)
4318 
    self._oprot.writeMessageEnd()
4319 
    self._oprot.trans.flush()
4320 
 
4321 
  def recv_markOrderCancellationRequestDenied(self, ):
4322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4323 
    if mtype == TMessageType.EXCEPTION:
4324 
      x = TApplicationException()
4325 
      x.read(self._iprot)
4326 
      self._iprot.readMessageEnd()
4327 
      raise x
4328 
    result = markOrderCancellationRequestDenied_result()
4329 
    result.read(self._iprot)
4330 
    self._iprot.readMessageEnd()
4331 
    if result.ex is not None:
4332 
      raise result.ex
4333 
    return
4334 
 
4258 rajveer 4335 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4336 
    """
4258 rajveer 4337 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4338 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4339 
 
4340 
    Parameters:
4258 rajveer 4341 
     - transactionId
4247 rajveer 4342 
    """
4258 rajveer 4343 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4344 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4345 
 
4258 rajveer 4346 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4347 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4348 
    args = markTransactionAsPaymentFlagRemoved_args()
4349 
    args.transactionId = transactionId
4247 rajveer 4350 
    args.write(self._oprot)
4351 
    self._oprot.writeMessageEnd()
4352 
    self._oprot.trans.flush()
4353 
 
4258 rajveer 4354 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4356 
    if mtype == TMessageType.EXCEPTION:
4357 
      x = TApplicationException()
4358 
      x.read(self._iprot)
4359 
      self._iprot.readMessageEnd()
4360 
      raise x
4258 rajveer 4361 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4362 
    result.read(self._iprot)
4363 
    self._iprot.readMessageEnd()
4364 
    if result.ex is not None:
4365 
      raise result.ex
4366 
    return
4367 
 
4259 anupam.sin 4368 
  def refundTransaction(self, transactionId, refundedBy, reason):
4369 
    """
4370 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4371 
    need to be cancelled
4247 rajveer 4372 
 
4259 anupam.sin 4373 
    Parameters:
4374 
     - transactionId
4375 
     - refundedBy
4376 
     - reason
4377 
    """
4378 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4379 
    self.recv_refundTransaction()
4380 
 
4381 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4382 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4383 
    args = refundTransaction_args()
4384 
    args.transactionId = transactionId
4385 
    args.refundedBy = refundedBy
4386 
    args.reason = reason
4387 
    args.write(self._oprot)
4388 
    self._oprot.writeMessageEnd()
4389 
    self._oprot.trans.flush()
4390 
 
4391 
  def recv_refundTransaction(self, ):
4392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4393 
    if mtype == TMessageType.EXCEPTION:
4394 
      x = TApplicationException()
4395 
      x.read(self._iprot)
4396 
      self._iprot.readMessageEnd()
4397 
      raise x
4398 
    result = refundTransaction_result()
4399 
    result.read(self._iprot)
4400 
    self._iprot.readMessageEnd()
4401 
    if result.ex is not None:
4402 
      raise result.ex
4403 
    return
4404 
 
4324 mandeep.dh 4405 
  def updateShipmentAddress(self, orderId, addressId):
4406 
    """
4407 
    Updates shipment address of an order. Delivery and shipping date estimates
4408 
    etc. are also updated here.
4409 
 
4410 
    Throws TransactionServiceException in case address change is not
4411 
    possible due to certain reasons such as new pincode in address is
4412 
    not serviceable etc.
4413 
 
4414 
    Parameters:
4415 
     - orderId
4416 
     - addressId
4417 
    """
4418 
    self.send_updateShipmentAddress(orderId, addressId)
4419 
    self.recv_updateShipmentAddress()
4420 
 
4421 
  def send_updateShipmentAddress(self, orderId, addressId):
4422 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4423 
    args = updateShipmentAddress_args()
4424 
    args.orderId = orderId
4425 
    args.addressId = addressId
4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_updateShipmentAddress(self, ):
4431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4432 
    if mtype == TMessageType.EXCEPTION:
4433 
      x = TApplicationException()
4434 
      x.read(self._iprot)
4435 
      self._iprot.readMessageEnd()
4436 
      raise x
4437 
    result = updateShipmentAddress_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.ex is not None:
4441 
      raise result.ex
4442 
    return
4443 
 
4285 rajveer 4444 
  def acceptOrdersForItemId(self, itemId, inventory):
4445 
    """
4446 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4447 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4448 
 
4285 rajveer 4449 
    Parameters:
4450 
     - itemId
4451 
     - inventory
4452 
    """
4453 
    self.send_acceptOrdersForItemId(itemId, inventory)
4454 
    return self.recv_acceptOrdersForItemId()
4455 
 
4456 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4457 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4458 
    args = acceptOrdersForItemId_args()
4459 
    args.itemId = itemId
4460 
    args.inventory = inventory
4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_acceptOrdersForItemId(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = acceptOrdersForItemId_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.success is not None:
4476 
      return result.success
4477 
    if result.ex is not None:
4478 
      raise result.ex
4479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4480 
 
4369 rajveer 4481 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4482 
    """
4483 
    Parameters:
4484 
     - vendorId
4485 
     - itemId
4486 
     - quantity
4487 
     - estimate
4369 rajveer 4488 
     - isReminder
4303 rajveer 4489 
    """
4369 rajveer 4490 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4491 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4492 
 
4369 rajveer 4493 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4494 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4495 
    args = markOrdersAsPORaised_args()
4496 
    args.vendorId = vendorId
4497 
    args.itemId = itemId
4498 
    args.quantity = quantity
4499 
    args.estimate = estimate
4369 rajveer 4500 
    args.isReminder = isReminder
4303 rajveer 4501 
    args.write(self._oprot)
4502 
    self._oprot.writeMessageEnd()
4503 
    self._oprot.trans.flush()
4504 
 
4505 
  def recv_markOrdersAsPORaised(self, ):
4506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4507 
    if mtype == TMessageType.EXCEPTION:
4508 
      x = TApplicationException()
4509 
      x.read(self._iprot)
4510 
      self._iprot.readMessageEnd()
4511 
      raise x
4512 
    result = markOrdersAsPORaised_result()
4513 
    result.read(self._iprot)
4514 
    self._iprot.readMessageEnd()
4515 
    if result.ex is not None:
4516 
      raise result.ex
4517 
    return
4518 
 
4369 rajveer 4519 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4520 
    """
4521 
    Parameters:
4522 
     - vendorId
4523 
     - itemId
4524 
     - quantity
4525 
     - estimate
4369 rajveer 4526 
     - isReminder
4303 rajveer 4527 
    """
4369 rajveer 4528 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4529 
    self.recv_markOrdersAsReversalInitiated()
4530 
 
4369 rajveer 4531 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4532 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4533 
    args = markOrdersAsReversalInitiated_args()
4534 
    args.vendorId = vendorId
4535 
    args.itemId = itemId
4536 
    args.quantity = quantity
4537 
    args.estimate = estimate
4369 rajveer 4538 
    args.isReminder = isReminder
4303 rajveer 4539 
    args.write(self._oprot)
4540 
    self._oprot.writeMessageEnd()
4541 
    self._oprot.trans.flush()
4542 
 
4543 
  def recv_markOrdersAsReversalInitiated(self, ):
4544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4545 
    if mtype == TMessageType.EXCEPTION:
4546 
      x = TApplicationException()
4547 
      x.read(self._iprot)
4548 
      self._iprot.readMessageEnd()
4549 
      raise x
4550 
    result = markOrdersAsReversalInitiated_result()
4551 
    result.read(self._iprot)
4552 
    self._iprot.readMessageEnd()
4553 
    if result.ex is not None:
4554 
      raise result.ex
4555 
    return
4556 
 
4369 rajveer 4557 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4558 
    """
4559 
    Parameters:
4560 
     - vendorId
4561 
     - itemId
4562 
     - quantity
4563 
     - estimate
4369 rajveer 4564 
     - isReminder
4303 rajveer 4565 
    """
4369 rajveer 4566 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4567 
    self.recv_markOrdersAsNotAvailabke()
4568 
 
4369 rajveer 4569 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4570 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4571 
    args = markOrdersAsNotAvailabke_args()
4572 
    args.vendorId = vendorId
4573 
    args.itemId = itemId
4574 
    args.quantity = quantity
4575 
    args.estimate = estimate
4369 rajveer 4576 
    args.isReminder = isReminder
4303 rajveer 4577 
    args.write(self._oprot)
4578 
    self._oprot.writeMessageEnd()
4579 
    self._oprot.trans.flush()
4580 
 
4581 
  def recv_markOrdersAsNotAvailabke(self, ):
4582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4583 
    if mtype == TMessageType.EXCEPTION:
4584 
      x = TApplicationException()
4585 
      x.read(self._iprot)
4586 
      self._iprot.readMessageEnd()
4587 
      raise x
4588 
    result = markOrdersAsNotAvailabke_result()
4589 
    result.read(self._iprot)
4590 
    self._iprot.readMessageEnd()
4591 
    if result.ex is not None:
4592 
      raise result.ex
4593 
    return
4594 
 
4369 rajveer 4595 
  def markOrdersAsTimeout(self, vendorId):
4596 
    """
4597 
    Parameters:
4598 
     - vendorId
4599 
    """
4600 
    self.send_markOrdersAsTimeout(vendorId)
4601 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4602 
 
4369 rajveer 4603 
  def send_markOrdersAsTimeout(self, vendorId):
4604 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4605 
    args = markOrdersAsTimeout_args()
4606 
    args.vendorId = vendorId
4607 
    args.write(self._oprot)
4608 
    self._oprot.writeMessageEnd()
4609 
    self._oprot.trans.flush()
4610 
 
4611 
  def recv_markOrdersAsTimeout(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 = markOrdersAsTimeout_result()
4619 
    result.read(self._iprot)
4620 
    self._iprot.readMessageEnd()
4621 
    if result.success is not None:
4622 
      return result.success
4623 
    if result.ex is not None:
4624 
      raise result.ex
4625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4626 
 
4662 rajveer 4627 
  def markOrderAsLostInTransit(self, orderId):
4628 
    """
4629 
    Mark order as LOST_IN_TRANSIT
4630 
 
4631 
    Parameters:
4632 
     - orderId
4633 
    """
4634 
    self.send_markOrderAsLostInTransit(orderId)
4635 
    return self.recv_markOrderAsLostInTransit()
4636 
 
4637 
  def send_markOrderAsLostInTransit(self, orderId):
4638 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4639 
    args = markOrderAsLostInTransit_args()
4640 
    args.orderId = orderId
4641 
    args.write(self._oprot)
4642 
    self._oprot.writeMessageEnd()
4643 
    self._oprot.trans.flush()
4644 
 
4645 
  def recv_markOrderAsLostInTransit(self, ):
4646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4647 
    if mtype == TMessageType.EXCEPTION:
4648 
      x = TApplicationException()
4649 
      x.read(self._iprot)
4650 
      self._iprot.readMessageEnd()
4651 
      raise x
4652 
    result = markOrderAsLostInTransit_result()
4653 
    result.read(self._iprot)
4654 
    self._iprot.readMessageEnd()
4655 
    if result.success is not None:
4656 
      return result.success
4657 
    if result.ex is not None:
4658 
      raise result.ex
4659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4660 
 
4386 anupam.sin 4661 
  def getOrderForAwb(self, awb):
4662 
    """
4663 
    Returns the order corresponding to an AWB number
4369 rajveer 4664 
 
4386 anupam.sin 4665 
    Parameters:
4666 
     - awb
4667 
    """
4668 
    self.send_getOrderForAwb(awb)
4669 
    return self.recv_getOrderForAwb()
4670 
 
4671 
  def send_getOrderForAwb(self, awb):
4672 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4673 
    args = getOrderForAwb_args()
4674 
    args.awb = awb
4675 
    args.write(self._oprot)
4676 
    self._oprot.writeMessageEnd()
4677 
    self._oprot.trans.flush()
4678 
 
4679 
  def recv_getOrderForAwb(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 = getOrderForAwb_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, "getOrderForAwb failed: unknown result");
4694 
 
4910 phani.kuma 4695 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4696 
    """
4910 phani.kuma 4697 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4698 
 
4506 phani.kuma 4699 
    Parameters:
4700 
     - logistics_provider_id
4910 phani.kuma 4701 
     - order_status_list
4506 phani.kuma 4702 
    """
4910 phani.kuma 4703 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4704 
    return self.recv_getOrdersForProviderForStatus()
4705 
 
4910 phani.kuma 4706 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4707 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4708 
    args = getOrdersForProviderForStatus_args()
4709 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4710 
    args.order_status_list = order_status_list
4506 phani.kuma 4711 
    args.write(self._oprot)
4712 
    self._oprot.writeMessageEnd()
4713 
    self._oprot.trans.flush()
4714 
 
4715 
  def recv_getOrdersForProviderForStatus(self, ):
4716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4717 
    if mtype == TMessageType.EXCEPTION:
4718 
      x = TApplicationException()
4719 
      x.read(self._iprot)
4720 
      self._iprot.readMessageEnd()
4721 
      raise x
4722 
    result = getOrdersForProviderForStatus_result()
4723 
    result.read(self._iprot)
4724 
    self._iprot.readMessageEnd()
4725 
    if result.success is not None:
4726 
      return result.success
4727 
    if result.ex is not None:
4728 
      raise result.ex
4729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4730 
 
4600 varun.gupt 4731 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4732 
    """
4733 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4734 
 
4600 varun.gupt 4735 
    Parameters:
4736 
     - vendorId
4737 
     - billingDateFrom
4738 
     - billingDateTo
4739 
    """
4740 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4741 
    return self.recv_getBilledOrdersForVendor()
4742 
 
4743 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4744 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4745 
    args = getBilledOrdersForVendor_args()
4746 
    args.vendorId = vendorId
4747 
    args.billingDateFrom = billingDateFrom
4748 
    args.billingDateTo = billingDateTo
4749 
    args.write(self._oprot)
4750 
    self._oprot.writeMessageEnd()
4751 
    self._oprot.trans.flush()
4752 
 
4753 
  def recv_getBilledOrdersForVendor(self, ):
4754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4755 
    if mtype == TMessageType.EXCEPTION:
4756 
      x = TApplicationException()
4757 
      x.read(self._iprot)
4758 
      self._iprot.readMessageEnd()
4759 
      raise x
4760 
    result = getBilledOrdersForVendor_result()
4761 
    result.read(self._iprot)
4762 
    self._iprot.readMessageEnd()
4763 
    if result.success is not None:
4764 
      return result.success
4765 
    if result.ex is not None:
4766 
      raise result.ex
4767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4768 
 
4607 rajveer 4769 
  def getSlippedSippingDateOrders(self, ):
4770 
    self.send_getSlippedSippingDateOrders()
4771 
    return self.recv_getSlippedSippingDateOrders()
4772 
 
4773 
  def send_getSlippedSippingDateOrders(self, ):
4774 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4775 
    args = getSlippedSippingDateOrders_args()
4776 
    args.write(self._oprot)
4777 
    self._oprot.writeMessageEnd()
4778 
    self._oprot.trans.flush()
4779 
 
4780 
  def recv_getSlippedSippingDateOrders(self, ):
4781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4782 
    if mtype == TMessageType.EXCEPTION:
4783 
      x = TApplicationException()
4784 
      x.read(self._iprot)
4785 
      self._iprot.readMessageEnd()
4786 
      raise x
4787 
    result = getSlippedSippingDateOrders_result()
4788 
    result.read(self._iprot)
4789 
    self._iprot.readMessageEnd()
4790 
    if result.success is not None:
4791 
      return result.success
4792 
    if result.ex is not None:
4793 
      raise result.ex
4794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4795 
 
4709 rajveer 4796 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4797 
    """
4798 
    Parameters:
4799 
     - cancelDateFrom
4800 
     - cancelDateTo
4801 
    """
4802 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4803 
    return self.recv_getCancelledOrders()
4804 
 
4805 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4806 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4807 
    args = getCancelledOrders_args()
4808 
    args.cancelDateFrom = cancelDateFrom
4809 
    args.cancelDateTo = cancelDateTo
4810 
    args.write(self._oprot)
4811 
    self._oprot.writeMessageEnd()
4812 
    self._oprot.trans.flush()
4813 
 
4814 
  def recv_getCancelledOrders(self, ):
4815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4816 
    if mtype == TMessageType.EXCEPTION:
4817 
      x = TApplicationException()
4818 
      x.read(self._iprot)
4819 
      self._iprot.readMessageEnd()
4820 
      raise x
4821 
    result = getCancelledOrders_result()
4822 
    result.read(self._iprot)
4823 
    self._iprot.readMessageEnd()
4824 
    if result.success is not None:
4825 
      return result.success
4826 
    if result.ex is not None:
4827 
      raise result.ex
4828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4829 
 
4600 varun.gupt 4830 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4831 
    """
4832 
    Parameters:
4833 
     - mapAWBAndAmount
4834 
    """
4835 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4836 
    self.recv_saveBluedartSettlements()
4837 
 
4838 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4839 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4840 
    args = saveBluedartSettlements_args()
4841 
    args.mapAWBAndAmount = mapAWBAndAmount
4842 
    args.write(self._oprot)
4843 
    self._oprot.writeMessageEnd()
4844 
    self._oprot.trans.flush()
4845 
 
4846 
  def recv_saveBluedartSettlements(self, ):
4847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4848 
    if mtype == TMessageType.EXCEPTION:
4849 
      x = TApplicationException()
4850 
      x.read(self._iprot)
4851 
      self._iprot.readMessageEnd()
4852 
      raise x
4853 
    result = saveBluedartSettlements_result()
4854 
    result.read(self._iprot)
4855 
    self._iprot.readMessageEnd()
4856 
    if result.ex is not None:
4857 
      raise result.ex
4858 
    return
4859 
 
4905 varun.gupt 4860 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4861 
    """
4862 
    Parameters:
4863 
     - settlementDate
4864 
     - paymentGatewayId
4905 varun.gupt 4865 
     - referenceId
4600 varun.gupt 4866 
     - serviceTax
4867 
     - otherCharges
4868 
     - netCollection
4869 
    """
4905 varun.gupt 4870 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4871 
    self.recv_savePaymentSettlements()
4872 
 
4905 varun.gupt 4873 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4874 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4875 
    args = savePaymentSettlements_args()
4876 
    args.settlementDate = settlementDate
4877 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4878 
    args.referenceId = referenceId
4600 varun.gupt 4879 
    args.serviceTax = serviceTax
4880 
    args.otherCharges = otherCharges
4881 
    args.netCollection = netCollection
4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_savePaymentSettlements(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = savePaymentSettlements_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.ex is not None:
4897 
      raise result.ex
4898 
    return
4899 
 
4900 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4901 
    """
4902 
    Parameters:
4903 
     - settlementId
4904 
     - settlementDate
4905 
     - transactionDateFrom
4906 
     - transactionDateTo
4907 
     - amount
4908 
    """
4909 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4910 
    self.recv_saveEBSSettlementSummary()
4911 
 
4912 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4913 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4914 
    args = saveEBSSettlementSummary_args()
4915 
    args.settlementId = settlementId
4916 
    args.settlementDate = settlementDate
4917 
    args.transactionDateFrom = transactionDateFrom
4918 
    args.transactionDateTo = transactionDateTo
4919 
    args.amount = amount
4920 
    args.write(self._oprot)
4921 
    self._oprot.writeMessageEnd()
4922 
    self._oprot.trans.flush()
4923 
 
4924 
  def recv_saveEBSSettlementSummary(self, ):
4925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4926 
    if mtype == TMessageType.EXCEPTION:
4927 
      x = TApplicationException()
4928 
      x.read(self._iprot)
4929 
      self._iprot.readMessageEnd()
4930 
      raise x
4931 
    result = saveEBSSettlementSummary_result()
4932 
    result.read(self._iprot)
4933 
    self._iprot.readMessageEnd()
4934 
    if result.ex is not None:
4935 
      raise result.ex
4936 
    return
4937 
 
5386 phani.kuma 4938 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4939 
    """
4940 
    Parameters:
5189 varun.gupt 4941 
     - referenceId
4942 
     - isRefund
4600 varun.gupt 4943 
    """
5386 phani.kuma 4944 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4945 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4946 
 
5386 phani.kuma 4947 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4948 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4949 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4950 
    args.referenceId = referenceId
4951 
    args.isRefund = isRefund
4600 varun.gupt 4952 
    args.write(self._oprot)
4953 
    self._oprot.writeMessageEnd()
4954 
    self._oprot.trans.flush()
4955 
 
5386 phani.kuma 4956 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4958 
    if mtype == TMessageType.EXCEPTION:
4959 
      x = TApplicationException()
4960 
      x.read(self._iprot)
4961 
      self._iprot.readMessageEnd()
4962 
      raise x
5386 phani.kuma 4963 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4964 
    result.read(self._iprot)
4965 
    self._iprot.readMessageEnd()
4966 
    if result.success is not None:
4967 
      return result.success
4968 
    if result.ex is not None:
4969 
      raise result.ex
5386 phani.kuma 4970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4971 
 
5386 phani.kuma 4972 
  def getSettlementForCod(self, orderId, isRefund):
4973 
    """
4974 
    Parameters:
4975 
     - orderId
4976 
     - isRefund
4977 
    """
4978 
    self.send_getSettlementForCod(orderId, isRefund)
4979 
    return self.recv_getSettlementForCod()
4980 
 
4981 
  def send_getSettlementForCod(self, orderId, isRefund):
4982 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4983 
    args = getSettlementForCod_args()
4984 
    args.orderId = orderId
4985 
    args.isRefund = isRefund
4986 
    args.write(self._oprot)
4987 
    self._oprot.writeMessageEnd()
4988 
    self._oprot.trans.flush()
4989 
 
4990 
  def recv_getSettlementForCod(self, ):
4991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4992 
    if mtype == TMessageType.EXCEPTION:
4993 
      x = TApplicationException()
4994 
      x.read(self._iprot)
4995 
      self._iprot.readMessageEnd()
4996 
      raise x
4997 
    result = getSettlementForCod_result()
4998 
    result.read(self._iprot)
4999 
    self._iprot.readMessageEnd()
5000 
    if result.success is not None:
5001 
      return result.success
5002 
    if result.ex is not None:
5003 
      raise result.ex
5004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5005 
 
4600 varun.gupt 5006 
  def getEBSSettlementSummaries(self, ):
5007 
    self.send_getEBSSettlementSummaries()
5008 
    return self.recv_getEBSSettlementSummaries()
5009 
 
5010 
  def send_getEBSSettlementSummaries(self, ):
5011 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5012 
    args = getEBSSettlementSummaries_args()
5013 
    args.write(self._oprot)
5014 
    self._oprot.writeMessageEnd()
5015 
    self._oprot.trans.flush()
5016 
 
5017 
  def recv_getEBSSettlementSummaries(self, ):
5018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5019 
    if mtype == TMessageType.EXCEPTION:
5020 
      x = TApplicationException()
5021 
      x.read(self._iprot)
5022 
      self._iprot.readMessageEnd()
5023 
      raise x
5024 
    result = getEBSSettlementSummaries_result()
5025 
    result.read(self._iprot)
5026 
    self._iprot.readMessageEnd()
5027 
    if result.success is not None:
5028 
      return result.success
5029 
    if result.ex is not None:
5030 
      raise result.ex
5031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5032 
 
5033 
  def markEBSSettlementUploaded(self, settlementId):
5034 
    """
5035 
    Parameters:
5036 
     - settlementId
5037 
    """
5038 
    self.send_markEBSSettlementUploaded(settlementId)
5039 
    self.recv_markEBSSettlementUploaded()
5040 
 
5041 
  def send_markEBSSettlementUploaded(self, settlementId):
5042 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5043 
    args = markEBSSettlementUploaded_args()
5044 
    args.settlementId = settlementId
5045 
    args.write(self._oprot)
5046 
    self._oprot.writeMessageEnd()
5047 
    self._oprot.trans.flush()
5048 
 
5049 
  def recv_markEBSSettlementUploaded(self, ):
5050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5051 
    if mtype == TMessageType.EXCEPTION:
5052 
      x = TApplicationException()
5053 
      x.read(self._iprot)
5054 
      self._iprot.readMessageEnd()
5055 
      raise x
5056 
    result = markEBSSettlementUploaded_result()
5057 
    result.read(self._iprot)
5058 
    self._iprot.readMessageEnd()
5059 
    if result.ex is not None:
5060 
      raise result.ex
5061 
    return
5062 
 
5063 
  def getEBSSettlementDate(self, settlementId):
5064 
    """
5065 
    Parameters:
5066 
     - settlementId
5067 
    """
5068 
    self.send_getEBSSettlementDate(settlementId)
5069 
    return self.recv_getEBSSettlementDate()
5070 
 
5071 
  def send_getEBSSettlementDate(self, settlementId):
5072 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5073 
    args = getEBSSettlementDate_args()
5074 
    args.settlementId = settlementId
5075 
    args.write(self._oprot)
5076 
    self._oprot.writeMessageEnd()
5077 
    self._oprot.trans.flush()
5078 
 
5079 
  def recv_getEBSSettlementDate(self, ):
5080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5081 
    if mtype == TMessageType.EXCEPTION:
5082 
      x = TApplicationException()
5083 
      x.read(self._iprot)
5084 
      self._iprot.readMessageEnd()
5085 
      raise x
5086 
    result = getEBSSettlementDate_result()
5087 
    result.read(self._iprot)
5088 
    self._iprot.readMessageEnd()
5089 
    if result.success is not None:
5090 
      return result.success
5091 
    if result.ex is not None:
5092 
      raise result.ex
5093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5094 
 
4715 varun.gupt 5095 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5096 
    """
5097 
    Parameters:
5098 
     - settlementDateFrom
5099 
     - settlementDateTo
5100 
     - isRefund
5101 
    """
5102 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5103 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5104 
 
4715 varun.gupt 5105 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5106 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5107 
    args = getSettlementsByDate_args()
5108 
    args.settlementDateFrom = settlementDateFrom
5109 
    args.settlementDateTo = settlementDateTo
5110 
    args.isRefund = isRefund
5111 
    args.write(self._oprot)
5112 
    self._oprot.writeMessageEnd()
5113 
    self._oprot.trans.flush()
5114 
 
5115 
  def recv_getSettlementsByDate(self, ):
5116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5117 
    if mtype == TMessageType.EXCEPTION:
5118 
      x = TApplicationException()
5119 
      x.read(self._iprot)
5120 
      self._iprot.readMessageEnd()
5121 
      raise x
5122 
    result = getSettlementsByDate_result()
5123 
    result.read(self._iprot)
5124 
    self._iprot.readMessageEnd()
5125 
    if result.success is not None:
5126 
      return result.success
5127 
    if result.ex is not None:
5128 
      raise result.ex
5129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5130 
 
5131 
  def getReshippedOrderIds(self, orderIds):
5132 
    """
5133 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5134 
 
5135 
    Parameters:
5136 
     - orderIds
5137 
    """
5138 
    self.send_getReshippedOrderIds(orderIds)
5139 
    return self.recv_getReshippedOrderIds()
5140 
 
5141 
  def send_getReshippedOrderIds(self, orderIds):
5142 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5143 
    args = getReshippedOrderIds_args()
5144 
    args.orderIds = orderIds
5145 
    args.write(self._oprot)
5146 
    self._oprot.writeMessageEnd()
5147 
    self._oprot.trans.flush()
5148 
 
5149 
  def recv_getReshippedOrderIds(self, ):
5150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5151 
    if mtype == TMessageType.EXCEPTION:
5152 
      x = TApplicationException()
5153 
      x.read(self._iprot)
5154 
      self._iprot.readMessageEnd()
5155 
      raise x
5156 
    result = getReshippedOrderIds_result()
5157 
    result.read(self._iprot)
5158 
    self._iprot.readMessageEnd()
5159 
    if result.success is not None:
5160 
      return result.success
5161 
    if result.ex is not None:
5162 
      raise result.ex
5163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5164 
 
5481 phani.kuma 5165 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5166 
    """
5167 
    Parameters:
5168 
     - vendorId
5481 phani.kuma 5169 
     - onlyVendorNotPaid
5170 
     - billingDateFrom
5171 
     - billingDateTo
4875 varun.gupt 5172 
    """
5481 phani.kuma 5173 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5174 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5175 
 
5481 phani.kuma 5176 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5177 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5178 
    args = getBilledOrders_args()
4875 varun.gupt 5179 
    args.vendorId = vendorId
5481 phani.kuma 5180 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5181 
    args.billingDateFrom = billingDateFrom
5182 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5183 
    args.write(self._oprot)
5184 
    self._oprot.writeMessageEnd()
5185 
    self._oprot.trans.flush()
5186 
 
5481 phani.kuma 5187 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5189 
    if mtype == TMessageType.EXCEPTION:
5190 
      x = TApplicationException()
5191 
      x.read(self._iprot)
5192 
      self._iprot.readMessageEnd()
5193 
      raise x
5481 phani.kuma 5194 
    result = getBilledOrders_result()
4875 varun.gupt 5195 
    result.read(self._iprot)
5196 
    self._iprot.readMessageEnd()
5197 
    if result.success is not None:
5198 
      return result.success
5199 
    if result.ex is not None:
5200 
      raise result.ex
5481 phani.kuma 5201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5202 
 
5031 varun.gupt 5203 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5204 
    """
5205 
    Parameters:
5206 
     - startDate
5207 
     - endDate
5208 
    """
5209 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5210 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5211 
 
5031 varun.gupt 5212 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5213 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5214 
    args = getStatusDistributionOfOrders_args()
5215 
    args.startDate = startDate
5216 
    args.endDate = endDate
5217 
    args.write(self._oprot)
5218 
    self._oprot.writeMessageEnd()
5219 
    self._oprot.trans.flush()
5220 
 
5221 
  def recv_getStatusDistributionOfOrders(self, ):
5222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5223 
    if mtype == TMessageType.EXCEPTION:
5224 
      x = TApplicationException()
5225 
      x.read(self._iprot)
5226 
      self._iprot.readMessageEnd()
5227 
      raise x
5228 
    result = getStatusDistributionOfOrders_result()
5229 
    result.read(self._iprot)
5230 
    self._iprot.readMessageEnd()
5231 
    if result.success is not None:
5232 
      return result.success
5233 
    if result.ex is not None:
5234 
      raise result.ex
5235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5236 
 
5067 varun.gupt 5237 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5238 
    """
5239 
    Parameters:
5240 
     - status
5241 
     - startDatetime
5242 
     - endDatetime
5243 
    """
5244 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5245 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5246 
 
5067 varun.gupt 5247 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5248 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5249 
    args = getOrderIdsForStatus_args()
5250 
    args.status = status
5251 
    args.startDatetime = startDatetime
5252 
    args.endDatetime = endDatetime
5253 
    args.write(self._oprot)
5254 
    self._oprot.writeMessageEnd()
5255 
    self._oprot.trans.flush()
5256 
 
5257 
  def recv_getOrderIdsForStatus(self, ):
5258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5259 
    if mtype == TMessageType.EXCEPTION:
5260 
      x = TApplicationException()
5261 
      x.read(self._iprot)
5262 
      self._iprot.readMessageEnd()
5263 
      raise x
5264 
    result = getOrderIdsForStatus_result()
5265 
    result.read(self._iprot)
5266 
    self._iprot.readMessageEnd()
5267 
    if result.success is not None:
5268 
      return result.success
5269 
    if result.ex is not None:
5270 
      raise result.ex
5271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5272 
 
5348 anupam.sin 5273 
  def updateCODAgent(self, agent, orderId):
5274 
    """
5275 
    Updates the agent who handled the COD verification call
5276 
 
5277 
    Parameters:
5278 
     - agent
5279 
     - orderId
5280 
    """
5281 
    self.send_updateCODAgent(agent, orderId)
5282 
    self.recv_updateCODAgent()
5283 
 
5284 
  def send_updateCODAgent(self, agent, orderId):
5285 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5286 
    args = updateCODAgent_args()
5287 
    args.agent = agent
5288 
    args.orderId = orderId
5289 
    args.write(self._oprot)
5290 
    self._oprot.writeMessageEnd()
5291 
    self._oprot.trans.flush()
5292 
 
5293 
  def recv_updateCODAgent(self, ):
5294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5295 
    if mtype == TMessageType.EXCEPTION:
5296 
      x = TApplicationException()
5297 
      x.read(self._iprot)
5298 
      self._iprot.readMessageEnd()
5299 
      raise x
5300 
    result = updateCODAgent_result()
5301 
    result.read(self._iprot)
5302 
    self._iprot.readMessageEnd()
5303 
    if result.ex is not None:
5304 
      raise result.ex
5305 
    return
5306 
 
5099 varun.gupt 5307 
  def updateOrderAsPaidToVendor(self, orderId):
5308 
    """
5309 
    Parameters:
5310 
     - orderId
5311 
    """
5312 
    self.send_updateOrderAsPaidToVendor(orderId)
5313 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5314 
 
5099 varun.gupt 5315 
  def send_updateOrderAsPaidToVendor(self, orderId):
5316 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5317 
    args = updateOrderAsPaidToVendor_args()
5318 
    args.orderId = orderId
5319 
    args.write(self._oprot)
5320 
    self._oprot.writeMessageEnd()
5321 
    self._oprot.trans.flush()
5322 
 
5323 
  def recv_updateOrderAsPaidToVendor(self, ):
5324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5325 
    if mtype == TMessageType.EXCEPTION:
5326 
      x = TApplicationException()
5327 
      x.read(self._iprot)
5328 
      self._iprot.readMessageEnd()
5329 
      raise x
5330 
    result = updateOrderAsPaidToVendor_result()
5331 
    result.read(self._iprot)
5332 
    self._iprot.readMessageEnd()
5333 
    if result.ex is not None:
5334 
      raise result.ex
5335 
    return
5336 
 
5386 phani.kuma 5337 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5338 
    """
5339 
    Parameters:
5340 
     - orderId
5341 
    """
5342 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5343 
    self.recv_updateOrderOnlyAsPaidToVendor()
5344 
 
5345 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5346 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5347 
    args = updateOrderOnlyAsPaidToVendor_args()
5348 
    args.orderId = orderId
5349 
    args.write(self._oprot)
5350 
    self._oprot.writeMessageEnd()
5351 
    self._oprot.trans.flush()
5352 
 
5353 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5355 
    if mtype == TMessageType.EXCEPTION:
5356 
      x = TApplicationException()
5357 
      x.read(self._iprot)
5358 
      self._iprot.readMessageEnd()
5359 
      raise x
5360 
    result = updateOrderOnlyAsPaidToVendor_result()
5361 
    result.read(self._iprot)
5362 
    self._iprot.readMessageEnd()
5363 
    if result.ex is not None:
5364 
      raise result.ex
5365 
    return
5366 
 
5208 varun.gupt 5367 
  def getRefundedOrdersMarkedPaid(self, ):
5368 
    self.send_getRefundedOrdersMarkedPaid()
5369 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5370 
 
5208 varun.gupt 5371 
  def send_getRefundedOrdersMarkedPaid(self, ):
5372 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5373 
    args = getRefundedOrdersMarkedPaid_args()
5374 
    args.write(self._oprot)
5375 
    self._oprot.writeMessageEnd()
5376 
    self._oprot.trans.flush()
5377 
 
5378 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5380 
    if mtype == TMessageType.EXCEPTION:
5381 
      x = TApplicationException()
5382 
      x.read(self._iprot)
5383 
      self._iprot.readMessageEnd()
5384 
      raise x
5385 
    result = getRefundedOrdersMarkedPaid_result()
5386 
    result.read(self._iprot)
5387 
    self._iprot.readMessageEnd()
5388 
    if result.success is not None:
5389 
      return result.success
5390 
    if result.ex is not None:
5391 
      raise result.ex
5392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5393 
 
5447 anupam.sin 5394 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5395 
    """
5396 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5397 
 
5447 anupam.sin 5398 
 
5399 
    Parameters:
5400 
     - minOrderId
5401 
     - maxOrderId
5402 
    """
5403 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5404 
    return self.recv_getAllVerificationAgents()
5405 
 
5406 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5407 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5408 
    args = getAllVerificationAgents_args()
5409 
    args.minOrderId = minOrderId
5410 
    args.maxOrderId = maxOrderId
5411 
    args.write(self._oprot)
5412 
    self._oprot.writeMessageEnd()
5413 
    self._oprot.trans.flush()
5414 
 
5415 
  def recv_getAllVerificationAgents(self, ):
5416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5417 
    if mtype == TMessageType.EXCEPTION:
5418 
      x = TApplicationException()
5419 
      x.read(self._iprot)
5420 
      self._iprot.readMessageEnd()
5421 
      raise x
5422 
    result = getAllVerificationAgents_result()
5423 
    result.read(self._iprot)
5424 
    self._iprot.readMessageEnd()
5425 
    if result.success is not None:
5426 
      return result.success
5427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5428 
 
5527 anupam.sin 5429 
  def getAllAttributesForOrderId(self, orderId):
5430 
    """
5431 
    gets all attributes for a given orderId
5447 anupam.sin 5432 
 
5527 anupam.sin 5433 
    Parameters:
5434 
     - orderId
5435 
    """
5436 
    self.send_getAllAttributesForOrderId(orderId)
5437 
    return self.recv_getAllAttributesForOrderId()
5438 
 
5439 
  def send_getAllAttributesForOrderId(self, orderId):
5440 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5441 
    args = getAllAttributesForOrderId_args()
5442 
    args.orderId = orderId
5443 
    args.write(self._oprot)
5444 
    self._oprot.writeMessageEnd()
5445 
    self._oprot.trans.flush()
5446 
 
5447 
  def recv_getAllAttributesForOrderId(self, ):
5448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5449 
    if mtype == TMessageType.EXCEPTION:
5450 
      x = TApplicationException()
5451 
      x.read(self._iprot)
5452 
      self._iprot.readMessageEnd()
5453 
      raise x
5454 
    result = getAllAttributesForOrderId_result()
5455 
    result.read(self._iprot)
5456 
    self._iprot.readMessageEnd()
5457 
    if result.success is not None:
5458 
      return result.success
5459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5460 
 
5676 rajveer 5461 
  def setOrderAttributes(self, orderId, attributes):
5462 
    """
5463 
    sets attributes for an order
5464 
 
5465 
    Parameters:
5466 
     - orderId
5467 
     - attributes
5468 
    """
5469 
    self.send_setOrderAttributes(orderId, attributes)
5470 
    self.recv_setOrderAttributes()
5471 
 
5472 
  def send_setOrderAttributes(self, orderId, attributes):
5473 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5474 
    args = setOrderAttributes_args()
5475 
    args.orderId = orderId
5476 
    args.attributes = attributes
5477 
    args.write(self._oprot)
5478 
    self._oprot.writeMessageEnd()
5479 
    self._oprot.trans.flush()
5480 
 
5481 
  def recv_setOrderAttributes(self, ):
5482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5483 
    if mtype == TMessageType.EXCEPTION:
5484 
      x = TApplicationException()
5485 
      x.read(self._iprot)
5486 
      self._iprot.readMessageEnd()
5487 
      raise x
5488 
    result = setOrderAttributes_result()
5489 
    result.read(self._iprot)
5490 
    self._iprot.readMessageEnd()
5491 
    return
5492 
 
5527 anupam.sin 5493 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5494 
    """
5495 
    sets attributes for all orders in a transaction
5496 
 
5497 
    Parameters:
5498 
     - transactionId
5499 
     - attribute
5500 
    """
5501 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5502 
    self.recv_setOrderAttributeForTransaction()
5503 
 
5504 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5505 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5506 
    args = setOrderAttributeForTransaction_args()
5507 
    args.transactionId = transactionId
5508 
    args.attribute = attribute
5509 
    args.write(self._oprot)
5510 
    self._oprot.writeMessageEnd()
5511 
    self._oprot.trans.flush()
5512 
 
5513 
  def recv_setOrderAttributeForTransaction(self, ):
5514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5515 
    if mtype == TMessageType.EXCEPTION:
5516 
      x = TApplicationException()
5517 
      x.read(self._iprot)
5518 
      self._iprot.readMessageEnd()
5519 
      raise x
5520 
    result = setOrderAttributeForTransaction_result()
5521 
    result.read(self._iprot)
5522 
    self._iprot.readMessageEnd()
5523 
    return
5524 
 
5553 rajveer 5525 
  def getReceivePendingOrders(self, storeId):
5526 
    """
5527 
    Parameters:
5528 
     - storeId
5529 
    """
5530 
    self.send_getReceivePendingOrders(storeId)
5531 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5532 
 
5553 rajveer 5533 
  def send_getReceivePendingOrders(self, storeId):
5534 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5535 
    args = getReceivePendingOrders_args()
5536 
    args.storeId = storeId
5537 
    args.write(self._oprot)
5538 
    self._oprot.writeMessageEnd()
5539 
    self._oprot.trans.flush()
5540 
 
5541 
  def recv_getReceivePendingOrders(self, ):
5542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5543 
    if mtype == TMessageType.EXCEPTION:
5544 
      x = TApplicationException()
5545 
      x.read(self._iprot)
5546 
      self._iprot.readMessageEnd()
5547 
      raise x
5548 
    result = getReceivePendingOrders_result()
5549 
    result.read(self._iprot)
5550 
    self._iprot.readMessageEnd()
5551 
    if result.success is not None:
5552 
      return result.success
5553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5554 
 
5555 
  def getReceivedAtStoreOrders(self, storeId):
5556 
    """
5557 
    Parameters:
5558 
     - storeId
5559 
    """
5560 
    self.send_getReceivedAtStoreOrders(storeId)
5561 
    return self.recv_getReceivedAtStoreOrders()
5562 
 
5563 
  def send_getReceivedAtStoreOrders(self, storeId):
5564 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5565 
    args = getReceivedAtStoreOrders_args()
5566 
    args.storeId = storeId
5567 
    args.write(self._oprot)
5568 
    self._oprot.writeMessageEnd()
5569 
    self._oprot.trans.flush()
5570 
 
5571 
  def recv_getReceivedAtStoreOrders(self, ):
5572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5573 
    if mtype == TMessageType.EXCEPTION:
5574 
      x = TApplicationException()
5575 
      x.read(self._iprot)
5576 
      self._iprot.readMessageEnd()
5577 
      raise x
5578 
    result = getReceivedAtStoreOrders_result()
5579 
    result.read(self._iprot)
5580 
    self._iprot.readMessageEnd()
5581 
    if result.success is not None:
5582 
      return result.success
5583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5584 
 
5713 rajveer 5585 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5586 
    """
5587 
    Parameters:
5588 
     - storeId
5589 
     - fromDate
5590 
     - toDate
5591 
     - onlyCod
5592 
    """
5593 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5594 
    return self.recv_getOrdersCollectionAtStore()
5595 
 
5596 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5597 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5598 
    args = getOrdersCollectionAtStore_args()
5599 
    args.storeId = storeId
5600 
    args.fromDate = fromDate
5601 
    args.toDate = toDate
5602 
    args.onlyCod = onlyCod
5603 
    args.write(self._oprot)
5604 
    self._oprot.writeMessageEnd()
5605 
    self._oprot.trans.flush()
5606 
 
5607 
  def recv_getOrdersCollectionAtStore(self, ):
5608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5609 
    if mtype == TMessageType.EXCEPTION:
5610 
      x = TApplicationException()
5611 
      x.read(self._iprot)
5612 
      self._iprot.readMessageEnd()
5613 
      raise x
5614 
    result = getOrdersCollectionAtStore_result()
5615 
    result.read(self._iprot)
5616 
    self._iprot.readMessageEnd()
5617 
    if result.success is not None:
5618 
      return result.success
5619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5620 
 
5833 rajveer 5621 
  def getOrderAttributeValue(self, orderId, attributeName):
5622 
    """
5623 
    Parameters:
5624 
     - orderId
5625 
     - attributeName
5626 
    """
5627 
    self.send_getOrderAttributeValue(orderId, attributeName)
5628 
    return self.recv_getOrderAttributeValue()
5629 
 
5630 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5631 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5632 
    args = getOrderAttributeValue_args()
5633 
    args.orderId = orderId
5634 
    args.attributeName = attributeName
5635 
    args.write(self._oprot)
5636 
    self._oprot.writeMessageEnd()
5637 
    self._oprot.trans.flush()
5638 
 
5639 
  def recv_getOrderAttributeValue(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 = getOrderAttributeValue_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, "getOrderAttributeValue failed: unknown result");
5652 
 
5593 mandeep.dh 5653 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5654 
    """
5655 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5656 
    invoked while scanning IN of items.
5553 rajveer 5657 
 
5593 mandeep.dh 5658 
    Parameters:
5659 
     - itemId
5660 
     - quantity
5661 
     - fulfilmentWarehouseId
5662 
     - billingWarehouseId
5663 
    """
5664 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5665 
    self.recv_acceptOrderForItem()
5666 
 
5667 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5668 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5669 
    args = acceptOrderForItem_args()
5670 
    args.itemId = itemId
5671 
    args.quantity = quantity
5672 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5673 
    args.billingWarehouseId = billingWarehouseId
5674 
    args.write(self._oprot)
5675 
    self._oprot.writeMessageEnd()
5676 
    self._oprot.trans.flush()
5677 
 
5678 
  def recv_acceptOrderForItem(self, ):
5679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5680 
    if mtype == TMessageType.EXCEPTION:
5681 
      x = TApplicationException()
5682 
      x.read(self._iprot)
5683 
      self._iprot.readMessageEnd()
5684 
      raise x
5685 
    result = acceptOrderForItem_result()
5686 
    result.read(self._iprot)
5687 
    self._iprot.readMessageEnd()
5688 
    return
5689 
 
6000 mandeep.dh 5690 
  def createRechargeOrder(self, rechargeOrder):
5691 
    """
5692 
    Parameters:
5693 
     - rechargeOrder
5694 
    """
5695 
    self.send_createRechargeOrder(rechargeOrder)
5696 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5697 
 
6000 mandeep.dh 5698 
  def send_createRechargeOrder(self, rechargeOrder):
5699 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5700 
    args = createRechargeOrder_args()
5701 
    args.rechargeOrder = rechargeOrder
5702 
    args.write(self._oprot)
5703 
    self._oprot.writeMessageEnd()
5704 
    self._oprot.trans.flush()
5705 
 
5706 
  def recv_createRechargeOrder(self, ):
5707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5708 
    if mtype == TMessageType.EXCEPTION:
5709 
      x = TApplicationException()
5710 
      x.read(self._iprot)
5711 
      self._iprot.readMessageEnd()
5712 
      raise x
5713 
    result = createRechargeOrder_result()
5714 
    result.read(self._iprot)
5715 
    self._iprot.readMessageEnd()
5716 
    if result.success is not None:
5717 
      return result.success
5718 
    if result.ex is not None:
5719 
      raise result.ex
5720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5721 
 
5722 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5723 
    """
5724 
    Parameters:
5725 
     - rechargeOrderId
5726 
     - rechargeOrderStatus
5727 
    """
5728 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
5729 
    self.recv_updateRechargeOrderStatus()
5730 
 
5731 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5732 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5733 
    args = updateRechargeOrderStatus_args()
5734 
    args.rechargeOrderId = rechargeOrderId
5735 
    args.rechargeOrderStatus = rechargeOrderStatus
5736 
    args.write(self._oprot)
5737 
    self._oprot.writeMessageEnd()
5738 
    self._oprot.trans.flush()
5739 
 
5740 
  def recv_updateRechargeOrderStatus(self, ):
5741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5742 
    if mtype == TMessageType.EXCEPTION:
5743 
      x = TApplicationException()
5744 
      x.read(self._iprot)
5745 
      self._iprot.readMessageEnd()
5746 
      raise x
5747 
    result = updateRechargeOrderStatus_result()
5748 
    result.read(self._iprot)
5749 
    self._iprot.readMessageEnd()
5750 
    if result.ex is not None:
5751 
      raise result.ex
5752 
    return
5753 
 
5754 
  def activateRechargeTxn(self, rechargeCoupons):
5755 
    """
5756 
    Parameters:
5757 
     - rechargeCoupons
5758 
    """
5759 
    self.send_activateRechargeTxn(rechargeCoupons)
5760 
    return self.recv_activateRechargeTxn()
5761 
 
5762 
  def send_activateRechargeTxn(self, rechargeCoupons):
5763 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5764 
    args = activateRechargeTxn_args()
5765 
    args.rechargeCoupons = rechargeCoupons
5766 
    args.write(self._oprot)
5767 
    self._oprot.writeMessageEnd()
5768 
    self._oprot.trans.flush()
5769 
 
5770 
  def recv_activateRechargeTxn(self, ):
5771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5772 
    if mtype == TMessageType.EXCEPTION:
5773 
      x = TApplicationException()
5774 
      x.read(self._iprot)
5775 
      self._iprot.readMessageEnd()
5776 
      raise x
5777 
    result = activateRechargeTxn_result()
5778 
    result.read(self._iprot)
5779 
    self._iprot.readMessageEnd()
5780 
    if result.success is not None:
5781 
      return result.success
5782 
    if result.ex is not None:
5783 
      raise result.ex
5784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5785 
 
5786 
  def getRechargeOrders(self, customerId):
5787 
    """
5788 
    Parameters:
5789 
     - customerId
5790 
    """
5791 
    self.send_getRechargeOrders(customerId)
5792 
    return self.recv_getRechargeOrders()
5793 
 
5794 
  def send_getRechargeOrders(self, customerId):
5795 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5796 
    args = getRechargeOrders_args()
5797 
    args.customerId = customerId
5798 
    args.write(self._oprot)
5799 
    self._oprot.writeMessageEnd()
5800 
    self._oprot.trans.flush()
5801 
 
5802 
  def recv_getRechargeOrders(self, ):
5803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5804 
    if mtype == TMessageType.EXCEPTION:
5805 
      x = TApplicationException()
5806 
      x.read(self._iprot)
5807 
      self._iprot.readMessageEnd()
5808 
      raise x
5809 
    result = getRechargeOrders_result()
5810 
    result.read(self._iprot)
5811 
    self._iprot.readMessageEnd()
5812 
    if result.success is not None:
5813 
      return result.success
5814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5815 
 
5816 
  def getRechargeCoupons(self, customerId, rechargeCouponStatus):
5817 
    """
5818 
    Parameters:
5819 
     - customerId
5820 
     - rechargeCouponStatus
5821 
    """
5822 
    self.send_getRechargeCoupons(customerId, rechargeCouponStatus)
5823 
    return self.recv_getRechargeCoupons()
5824 
 
5825 
  def send_getRechargeCoupons(self, customerId, rechargeCouponStatus):
5826 
    self._oprot.writeMessageBegin('getRechargeCoupons', TMessageType.CALL, self._seqid)
5827 
    args = getRechargeCoupons_args()
5828 
    args.customerId = customerId
5829 
    args.rechargeCouponStatus = rechargeCouponStatus
5830 
    args.write(self._oprot)
5831 
    self._oprot.writeMessageEnd()
5832 
    self._oprot.trans.flush()
5833 
 
5834 
  def recv_getRechargeCoupons(self, ):
5835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5836 
    if mtype == TMessageType.EXCEPTION:
5837 
      x = TApplicationException()
5838 
      x.read(self._iprot)
5839 
      self._iprot.readMessageEnd()
5840 
      raise x
5841 
    result = getRechargeCoupons_result()
5842 
    result.read(self._iprot)
5843 
    self._iprot.readMessageEnd()
5844 
    if result.success is not None:
5845 
      return result.success
5846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeCoupons failed: unknown result");
5847 
 
5848 
 
3376 rajveer 5849 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5850 
  def __init__(self, handler):
3376 rajveer 5851 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5852 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5853 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5854 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5855 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5856 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5857 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5858 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5859 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5860 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5861 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5862 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5863 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5864 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5865 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5866 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5867 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5868 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5869 
    self._processMap["createOrder"] = Processor.process_createOrder
5870 
    self._processMap["getOrder"] = Processor.process_getOrder
5871 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5872 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5873 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5874 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5875 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5876 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5877 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5878 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5879 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5880 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5881 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5882 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5883 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5884 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5885 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5886 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5887 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5888 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5889 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5890 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5891 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5892 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5893 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5894 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5895 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5896 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5897 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5898 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5899 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5900 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5901 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5902 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5903 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5904 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5905 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5906 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5907 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5908 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5909 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5910 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5911 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5912 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5913 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5914 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5915 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5916 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5917 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5918 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5919 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5920 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5921 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5922 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5923 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5924 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5925 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5926 
    self._processMap["changeItem"] = Processor.process_changeItem
5927 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5928 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5929 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5930 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5931 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5932 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5933 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5934 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5935 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5936 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5937 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5938 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5939 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5940 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5941 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5942 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5943 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5944 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5945 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5946 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5947 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5948 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5949 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5950 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5951 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5952 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5953 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5954 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5955 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5956 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5957 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5958 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5959 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5960 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5961 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5962 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5963 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5964 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5965 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5966 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5967 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5968 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5969 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 5970 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 5971 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5972 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5973 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 5974 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 5975 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
5593 mandeep.dh 5976 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 5977 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
5978 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
5979 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
5980 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
5981 
    self._processMap["getRechargeCoupons"] = Processor.process_getRechargeCoupons
94 ashish 5982 
 
5983 
  def process(self, iprot, oprot):
5984 
    (name, type, seqid) = iprot.readMessageBegin()
5985 
    if name not in self._processMap:
5986 
      iprot.skip(TType.STRUCT)
5987 
      iprot.readMessageEnd()
5988 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5989 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5990 
      x.write(oprot)
5991 
      oprot.writeMessageEnd()
5992 
      oprot.trans.flush()
5993 
      return
5994 
    else:
5995 
      self._processMap[name](self, seqid, iprot, oprot)
5996 
    return True
5997 
 
5998 
  def process_createTransaction(self, seqid, iprot, oprot):
5999 
    args = createTransaction_args()
6000 
    args.read(iprot)
6001 
    iprot.readMessageEnd()
6002 
    result = createTransaction_result()
6003 
    try:
132 ashish 6004 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6005 
    except TransactionServiceException, ex:
6006 
      result.ex = ex
6007 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6008 
    result.write(oprot)
6009 
    oprot.writeMessageEnd()
6010 
    oprot.trans.flush()
6011 
 
6012 
  def process_getTransaction(self, seqid, iprot, oprot):
6013 
    args = getTransaction_args()
6014 
    args.read(iprot)
6015 
    iprot.readMessageEnd()
6016 
    result = getTransaction_result()
6017 
    try:
6018 
      result.success = self._handler.getTransaction(args.id)
6019 
    except TransactionServiceException, ex:
6020 
      result.ex = ex
6021 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6022 
    result.write(oprot)
6023 
    oprot.writeMessageEnd()
6024 
    oprot.trans.flush()
6025 
 
6026 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6027 
    args = getTransactionsForCustomer_args()
6028 
    args.read(iprot)
6029 
    iprot.readMessageEnd()
6030 
    result = getTransactionsForCustomer_result()
6031 
    try:
6032 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6033 
    except TransactionServiceException, ex:
6034 
      result.ex = ex
6035 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6036 
    result.write(oprot)
6037 
    oprot.writeMessageEnd()
6038 
    oprot.trans.flush()
6039 
 
132 ashish 6040 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6041 
    args = getTransactionsForShoppingCartId_args()
6042 
    args.read(iprot)
6043 
    iprot.readMessageEnd()
6044 
    result = getTransactionsForShoppingCartId_result()
6045 
    try:
6046 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6047 
    except TransactionServiceException, ex:
6048 
      result.ex = ex
6049 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6050 
    result.write(oprot)
6051 
    oprot.writeMessageEnd()
6052 
    oprot.trans.flush()
6053 
 
94 ashish 6054 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6055 
    args = getTransactionStatus_args()
6056 
    args.read(iprot)
6057 
    iprot.readMessageEnd()
6058 
    result = getTransactionStatus_result()
6059 
    try:
6060 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6061 
    except TransactionServiceException, ex:
6062 
      result.ex = ex
6063 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6064 
    result.write(oprot)
6065 
    oprot.writeMessageEnd()
6066 
    oprot.trans.flush()
6067 
 
6068 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6069 
    args = changeTransactionStatus_args()
6070 
    args.read(iprot)
6071 
    iprot.readMessageEnd()
6072 
    result = changeTransactionStatus_result()
6073 
    try:
5527 anupam.sin 6074 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6075 
    except TransactionServiceException, ex:
6076 
      result.ex = ex
6077 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6078 
    result.write(oprot)
6079 
    oprot.writeMessageEnd()
6080 
    oprot.trans.flush()
6081 
 
1398 varun.gupt 6082 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6083 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6084 
    args.read(iprot)
6085 
    iprot.readMessageEnd()
1398 varun.gupt 6086 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6087 
    try:
1398 varun.gupt 6088 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6089 
    except TransactionServiceException, ex:
6090 
      result.ex = ex
1398 varun.gupt 6091 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6092 
    result.write(oprot)
6093 
    oprot.writeMessageEnd()
6094 
    oprot.trans.flush()
6095 
 
483 rajveer 6096 
  def process_getAllOrders(self, seqid, iprot, oprot):
6097 
    args = getAllOrders_args()
94 ashish 6098 
    args.read(iprot)
6099 
    iprot.readMessageEnd()
483 rajveer 6100 
    result = getAllOrders_result()
94 ashish 6101 
    try:
4801 anupam.sin 6102 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6103 
    except TransactionServiceException, ex:
6104 
      result.ex = ex
483 rajveer 6105 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6106 
    result.write(oprot)
6107 
    oprot.writeMessageEnd()
6108 
    oprot.trans.flush()
6109 
 
4133 chandransh 6110 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6111 
    args = getOrdersInBatch_args()
6112 
    args.read(iprot)
6113 
    iprot.readMessageEnd()
6114 
    result = getOrdersInBatch_result()
6115 
    try:
6116 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6117 
    except TransactionServiceException, ex:
6118 
      result.ex = ex
6119 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6120 
    result.write(oprot)
6121 
    oprot.writeMessageEnd()
6122 
    oprot.trans.flush()
6123 
 
6124 
  def process_getOrderCount(self, seqid, iprot, oprot):
6125 
    args = getOrderCount_args()
6126 
    args.read(iprot)
6127 
    iprot.readMessageEnd()
6128 
    result = getOrderCount_result()
6129 
    try:
6130 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6131 
    except TransactionServiceException, ex:
6132 
      result.ex = ex
6133 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6134 
    result.write(oprot)
6135 
    oprot.writeMessageEnd()
6136 
    oprot.trans.flush()
6137 
 
999 varun.gupt 6138 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6139 
    args = getOrdersByBillingDate_args()
6140 
    args.read(iprot)
6141 
    iprot.readMessageEnd()
6142 
    result = getOrdersByBillingDate_result()
6143 
    try:
6144 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6145 
    except TransactionServiceException, ex:
6146 
      result.ex = ex
6147 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6148 
    result.write(oprot)
6149 
    oprot.writeMessageEnd()
6150 
    oprot.trans.flush()
6151 
 
3427 chandransh 6152 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6153 
    args = getOrdersByShippingDate_args()
6154 
    args.read(iprot)
6155 
    iprot.readMessageEnd()
6156 
    result = getOrdersByShippingDate_result()
6157 
    try:
3451 chandransh 6158 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6159 
    except TransactionServiceException, ex:
6160 
      result.ex = ex
6161 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6162 
    result.write(oprot)
6163 
    oprot.writeMessageEnd()
6164 
    oprot.trans.flush()
6165 
 
1382 varun.gupt 6166 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6167 
    args = getReturnableOrdersForCustomer_args()
6168 
    args.read(iprot)
6169 
    iprot.readMessageEnd()
6170 
    result = getReturnableOrdersForCustomer_result()
6171 
    try:
6172 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6173 
    except TransactionServiceException, ex:
6174 
      result.ex = ex
6175 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6176 
    result.write(oprot)
6177 
    oprot.writeMessageEnd()
6178 
    oprot.trans.flush()
6179 
 
6180 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6181 
    args = getCancellableOrdersForCustomer_args()
6182 
    args.read(iprot)
6183 
    iprot.readMessageEnd()
6184 
    result = getCancellableOrdersForCustomer_result()
6185 
    try:
6186 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6187 
    except TransactionServiceException, ex:
6188 
      result.ex = ex
6189 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6190 
    result.write(oprot)
6191 
    oprot.writeMessageEnd()
6192 
    oprot.trans.flush()
6193 
 
483 rajveer 6194 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6195 
    args = changeOrderStatus_args()
94 ashish 6196 
    args.read(iprot)
6197 
    iprot.readMessageEnd()
483 rajveer 6198 
    result = changeOrderStatus_result()
94 ashish 6199 
    try:
483 rajveer 6200 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6201 
    except TransactionServiceException, ex:
6202 
      result.ex = ex
483 rajveer 6203 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6204 
    result.write(oprot)
6205 
    oprot.writeMessageEnd()
6206 
    oprot.trans.flush()
6207 
 
483 rajveer 6208 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6209 
    args = getOrdersForTransaction_args()
94 ashish 6210 
    args.read(iprot)
6211 
    iprot.readMessageEnd()
483 rajveer 6212 
    result = getOrdersForTransaction_result()
94 ashish 6213 
    try:
1528 ankur.sing 6214 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6215 
    except TransactionServiceException, ex:
6216 
      result.ex = ex
483 rajveer 6217 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6218 
    result.write(oprot)
6219 
    oprot.writeMessageEnd()
6220 
    oprot.trans.flush()
6221 
 
483 rajveer 6222 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6223 
    args = getOrdersForCustomer_args()
94 ashish 6224 
    args.read(iprot)
6225 
    iprot.readMessageEnd()
483 rajveer 6226 
    result = getOrdersForCustomer_result()
94 ashish 6227 
    try:
3014 chandransh 6228 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6229 
    except TransactionServiceException, ex:
6230 
      result.ex = ex
483 rajveer 6231 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6232 
    result.write(oprot)
6233 
    oprot.writeMessageEnd()
6234 
    oprot.trans.flush()
6235 
 
483 rajveer 6236 
  def process_createOrder(self, seqid, iprot, oprot):
6237 
    args = createOrder_args()
94 ashish 6238 
    args.read(iprot)
6239 
    iprot.readMessageEnd()
483 rajveer 6240 
    result = createOrder_result()
94 ashish 6241 
    try:
483 rajveer 6242 
      result.success = self._handler.createOrder(args.order)
94 ashish 6243 
    except TransactionServiceException, ex:
6244 
      result.ex = ex
483 rajveer 6245 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6246 
    result.write(oprot)
6247 
    oprot.writeMessageEnd()
6248 
    oprot.trans.flush()
6249 
 
483 rajveer 6250 
  def process_getOrder(self, seqid, iprot, oprot):
6251 
    args = getOrder_args()
94 ashish 6252 
    args.read(iprot)
6253 
    iprot.readMessageEnd()
483 rajveer 6254 
    result = getOrder_result()
94 ashish 6255 
    try:
483 rajveer 6256 
      result.success = self._handler.getOrder(args.id)
94 ashish 6257 
    except TransactionServiceException, ex:
6258 
      result.ex = ex
483 rajveer 6259 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6260 
    result.write(oprot)
6261 
    oprot.writeMessageEnd()
6262 
    oprot.trans.flush()
6263 
 
483 rajveer 6264 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6265 
    args = getLineItemsForOrder_args()
94 ashish 6266 
    args.read(iprot)
6267 
    iprot.readMessageEnd()
483 rajveer 6268 
    result = getLineItemsForOrder_result()
94 ashish 6269 
    try:
483 rajveer 6270 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6271 
    except TransactionServiceException, ex:
6272 
      result.ex = ex
483 rajveer 6273 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6274 
    result.write(oprot)
6275 
    oprot.writeMessageEnd()
6276 
    oprot.trans.flush()
6277 
 
4999 phani.kuma 6278 
  def process_getOrderList(self, seqid, iprot, oprot):
6279 
    args = getOrderList_args()
6280 
    args.read(iprot)
6281 
    iprot.readMessageEnd()
6282 
    result = getOrderList_result()
6283 
    result.success = self._handler.getOrderList(args.order_ids)
6284 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6285 
    result.write(oprot)
6286 
    oprot.writeMessageEnd()
6287 
    oprot.trans.flush()
6288 
 
5386 phani.kuma 6289 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6290 
    args = getOrderListForVendor_args()
6291 
    args.read(iprot)
6292 
    iprot.readMessageEnd()
6293 
    result = getOrderListForVendor_result()
6294 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6295 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6296 
    result.write(oprot)
6297 
    oprot.writeMessageEnd()
6298 
    oprot.trans.flush()
6299 
 
1528 ankur.sing 6300 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6301 
    args = getOrderForCustomer_args()
6302 
    args.read(iprot)
6303 
    iprot.readMessageEnd()
6304 
    result = getOrderForCustomer_result()
6305 
    try:
6306 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6307 
    except TransactionServiceException, ex:
6308 
      result.ex = ex
6309 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6310 
    result.write(oprot)
6311 
    oprot.writeMessageEnd()
6312 
    oprot.trans.flush()
6313 
 
3064 chandransh 6314 
  def process_getAlerts(self, seqid, iprot, oprot):
6315 
    args = getAlerts_args()
6316 
    args.read(iprot)
6317 
    iprot.readMessageEnd()
6318 
    result = getAlerts_result()
4444 rajveer 6319 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6320 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6321 
    result.write(oprot)
6322 
    oprot.writeMessageEnd()
6323 
    oprot.trans.flush()
6324 
 
4394 rajveer 6325 
  def process_addAlert(self, seqid, iprot, oprot):
6326 
    args = addAlert_args()
3064 chandransh 6327 
    args.read(iprot)
6328 
    iprot.readMessageEnd()
4394 rajveer 6329 
    result = addAlert_result()
4444 rajveer 6330 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6331 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6332 
    result.write(oprot)
6333 
    oprot.writeMessageEnd()
6334 
    oprot.trans.flush()
6335 
 
4444 rajveer 6336 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6337 
    args = markAlertsAsSeen_args()
6338 
    args.read(iprot)
6339 
    iprot.readMessageEnd()
6340 
    result = markAlertsAsSeen_result()
6341 
    self._handler.markAlertsAsSeen(args.warehouseId)
6342 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6343 
    result.write(oprot)
6344 
    oprot.writeMessageEnd()
6345 
    oprot.trans.flush()
6346 
 
3064 chandransh 6347 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6348 
    args = getValidOrderCount_args()
6349 
    args.read(iprot)
6350 
    iprot.readMessageEnd()
6351 
    result = getValidOrderCount_result()
6352 
    result.success = self._handler.getValidOrderCount()
6353 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6354 
    result.write(oprot)
6355 
    oprot.writeMessageEnd()
6356 
    oprot.trans.flush()
6357 
 
6358 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6359 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6360 
    args.read(iprot)
6361 
    iprot.readMessageEnd()
6362 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6363 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6364 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6365 
    result.write(oprot)
6366 
    oprot.writeMessageEnd()
6367 
    oprot.trans.flush()
6368 
 
6369 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6370 
    args = getValidOrdersAmountRange_args()
6371 
    args.read(iprot)
6372 
    iprot.readMessageEnd()
6373 
    result = getValidOrdersAmountRange_result()
6374 
    result.success = self._handler.getValidOrdersAmountRange()
6375 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6376 
    result.write(oprot)
6377 
    oprot.writeMessageEnd()
6378 
    oprot.trans.flush()
6379 
 
6380 
  def process_getValidOrders(self, seqid, iprot, oprot):
6381 
    args = getValidOrders_args()
6382 
    args.read(iprot)
6383 
    iprot.readMessageEnd()
6384 
    result = getValidOrders_result()
5874 rajveer 6385 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6386 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6387 
    result.write(oprot)
6388 
    oprot.writeMessageEnd()
6389 
    oprot.trans.flush()
6390 
 
1220 chandransh 6391 
  def process_batchOrders(self, seqid, iprot, oprot):
6392 
    args = batchOrders_args()
6393 
    args.read(iprot)
6394 
    iprot.readMessageEnd()
6395 
    result = batchOrders_result()
6396 
    try:
6397 
      result.success = self._handler.batchOrders(args.warehouseId)
6398 
    except TransactionServiceException, ex:
6399 
      result.ex = ex
6400 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6401 
    result.write(oprot)
6402 
    oprot.writeMessageEnd()
6403 
    oprot.trans.flush()
6404 
 
1208 chandransh 6405 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6406 
    args = markOrderAsOutOfStock_args()
6407 
    args.read(iprot)
6408 
    iprot.readMessageEnd()
6409 
    result = markOrderAsOutOfStock_result()
6410 
    try:
6411 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6412 
    except TransactionServiceException, ex:
6413 
      result.ex = ex
6414 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6415 
    result.write(oprot)
6416 
    oprot.writeMessageEnd()
6417 
    oprot.trans.flush()
6418 
 
3064 chandransh 6419 
  def process_verifyOrder(self, seqid, iprot, oprot):
6420 
    args = verifyOrder_args()
759 chandransh 6421 
    args.read(iprot)
6422 
    iprot.readMessageEnd()
3064 chandransh 6423 
    result = verifyOrder_result()
759 chandransh 6424 
    try:
3064 chandransh 6425 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6426 
    except TransactionServiceException, ex:
6427 
      result.ex = ex
3064 chandransh 6428 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
6432 
 
3064 chandransh 6433 
  def process_acceptOrder(self, seqid, iprot, oprot):
6434 
    args = acceptOrder_args()
1113 chandransh 6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
3064 chandransh 6437 
    result = acceptOrder_result()
1113 chandransh 6438 
    try:
3064 chandransh 6439 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6440 
    except TransactionServiceException, ex:
6441 
      result.ex = ex
3064 chandransh 6442 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6443 
    result.write(oprot)
6444 
    oprot.writeMessageEnd()
6445 
    oprot.trans.flush()
6446 
 
3064 chandransh 6447 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6448 
    args = addBillingDetails_args()
1135 chandransh 6449 
    args.read(iprot)
6450 
    iprot.readMessageEnd()
3064 chandransh 6451 
    result = addBillingDetails_result()
1135 chandransh 6452 
    try:
5110 mandeep.dh 6453 
      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 6454 
    except TransactionServiceException, ex:
6455 
      result.ex = ex
3064 chandransh 6456 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6457 
    result.write(oprot)
6458 
    oprot.writeMessageEnd()
6459 
    oprot.trans.flush()
6460 
 
4579 rajveer 6461 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6462 
    args = addInvoiceNumber_args()
6463 
    args.read(iprot)
6464 
    iprot.readMessageEnd()
6465 
    result = addInvoiceNumber_result()
6466 
    try:
4763 rajveer 6467 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6468 
    except TransactionServiceException, ex:
6469 
      result.ex = ex
6470 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6471 
    result.write(oprot)
6472 
    oprot.writeMessageEnd()
6473 
    oprot.trans.flush()
6474 
 
4410 rajveer 6475 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6476 
    args = markOrdersAsShippedFromWarehouse_args()
6477 
    args.read(iprot)
6478 
    iprot.readMessageEnd()
6479 
    result = markOrdersAsShippedFromWarehouse_result()
6480 
    try:
4789 rajveer 6481 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6482 
    except TransactionServiceException, ex:
6483 
      result.ex = ex
6484 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6485 
    result.write(oprot)
6486 
    oprot.writeMessageEnd()
6487 
    oprot.trans.flush()
6488 
 
5676 rajveer 6489 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6490 
    args = markOrdersAsReturnedFromStore_args()
6491 
    args.read(iprot)
6492 
    iprot.readMessageEnd()
6493 
    result = markOrdersAsReturnedFromStore_result()
6494 
    try:
5713 rajveer 6495 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6496 
    except TransactionServiceException, ex:
6497 
      result.ex = ex
6498 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6499 
    result.write(oprot)
6500 
    oprot.writeMessageEnd()
6501 
    oprot.trans.flush()
6502 
 
3064 chandransh 6503 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6504 
    args = markOrdersAsPickedUp_args()
304 ashish 6505 
    args.read(iprot)
6506 
    iprot.readMessageEnd()
3064 chandransh 6507 
    result = markOrdersAsPickedUp_result()
6508 
    try:
4910 phani.kuma 6509 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6510 
    except TransactionServiceException, ex:
6511 
      result.ex = ex
6512 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6513 
    result.write(oprot)
6514 
    oprot.writeMessageEnd()
6515 
    oprot.trans.flush()
94 ashish 6516 
 
4910 phani.kuma 6517 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6518 
    args = getOrdersNotPickedUp_args()
6519 
    args.read(iprot)
6520 
    iprot.readMessageEnd()
6521 
    result = getOrdersNotPickedUp_result()
6522 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6523 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6524 
    result.write(oprot)
6525 
    oprot.writeMessageEnd()
6526 
    oprot.trans.flush()
6527 
 
3064 chandransh 6528 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6529 
    args = markOrdersAsDelivered_args()
304 ashish 6530 
    args.read(iprot)
6531 
    iprot.readMessageEnd()
3064 chandransh 6532 
    result = markOrdersAsDelivered_result()
6533 
    try:
6534 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6535 
    except TransactionServiceException, ex:
6536 
      result.ex = ex
6537 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6538 
    result.write(oprot)
6539 
    oprot.writeMessageEnd()
6540 
    oprot.trans.flush()
6541 
 
4910 phani.kuma 6542 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6543 
    args = markAsRTOrders_args()
1596 ankur.sing 6544 
    args.read(iprot)
6545 
    iprot.readMessageEnd()
4910 phani.kuma 6546 
    result = markAsRTOrders_result()
3064 chandransh 6547 
    try:
4910 phani.kuma 6548 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6549 
    except TransactionServiceException, ex:
6550 
      result.ex = ex
4910 phani.kuma 6551 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6552 
    result.write(oprot)
6553 
    oprot.writeMessageEnd()
6554 
    oprot.trans.flush()
304 ashish 6555 
 
4910 phani.kuma 6556 
  def process_getRTOrders(self, seqid, iprot, oprot):
6557 
    args = getRTOrders_args()
6558 
    args.read(iprot)
6559 
    iprot.readMessageEnd()
6560 
    result = getRTOrders_result()
6561 
    result.success = self._handler.getRTOrders(args.providerId)
6562 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6563 
    result.write(oprot)
6564 
    oprot.writeMessageEnd()
6565 
    oprot.trans.flush()
6566 
 
3064 chandransh 6567 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6568 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6569 
    args.read(iprot)
6570 
    iprot.readMessageEnd()
3064 chandransh 6571 
    result = updateNonDeliveryReason_result()
6572 
    try:
4910 phani.kuma 6573 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6574 
    except TransactionServiceException, ex:
6575 
      result.ex = ex
6576 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6577 
    result.write(oprot)
6578 
    oprot.writeMessageEnd()
6579 
    oprot.trans.flush()
1596 ankur.sing 6580 
 
4910 phani.kuma 6581 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6582 
    args = getNonDeliveredOrdersbyCourier_args()
6583 
    args.read(iprot)
6584 
    iprot.readMessageEnd()
6585 
    result = getNonDeliveredOrdersbyCourier_result()
6586 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6587 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6588 
    result.write(oprot)
6589 
    oprot.writeMessageEnd()
6590 
    oprot.trans.flush()
6591 
 
6592 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6593 
    args = markOrdersAsLocalConnected_args()
6594 
    args.read(iprot)
6595 
    iprot.readMessageEnd()
6596 
    result = markOrdersAsLocalConnected_result()
6597 
    try:
6598 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6599 
    except TransactionServiceException, ex:
6600 
      result.ex = ex
6601 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6602 
    result.write(oprot)
6603 
    oprot.writeMessageEnd()
6604 
    oprot.trans.flush()
6605 
 
6606 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6607 
    args = getOrdersNotLocalConnected_args()
6608 
    args.read(iprot)
6609 
    iprot.readMessageEnd()
6610 
    result = getOrdersNotLocalConnected_result()
6611 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6612 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6613 
    result.write(oprot)
6614 
    oprot.writeMessageEnd()
6615 
    oprot.trans.flush()
6616 
 
6617 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6618 
    args = markOrdersAsDestinationCityReached_args()
6619 
    args.read(iprot)
6620 
    iprot.readMessageEnd()
6621 
    result = markOrdersAsDestinationCityReached_result()
6622 
    try:
6623 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6624 
    except TransactionServiceException, ex:
6625 
      result.ex = ex
6626 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6631 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6632 
    args = markOrdersAsFirstDeliveryAttempted_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = markOrdersAsFirstDeliveryAttempted_result()
6636 
    try:
6637 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6638 
    except TransactionServiceException, ex:
6639 
      result.ex = ex
6640 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
3064 chandransh 6645 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6646 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6647 
    args.read(iprot)
6648 
    iprot.readMessageEnd()
3064 chandransh 6649 
    result = getUndeliveredOrders_result()
6650 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6651 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6652 
    result.write(oprot)
6653 
    oprot.writeMessageEnd()
6654 
    oprot.trans.flush()
6655 
 
4783 phani.kuma 6656 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6657 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6658 
    args.read(iprot)
6659 
    iprot.readMessageEnd()
6660 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6661 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6662 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6663 
    result.write(oprot)
6664 
    oprot.writeMessageEnd()
6665 
    oprot.trans.flush()
6666 
 
2536 chandransh 6667 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6668 
    args = toggleDOAFlag_args()
6669 
    args.read(iprot)
6670 
    iprot.readMessageEnd()
6671 
    result = toggleDOAFlag_result()
6672 
    try:
6673 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6674 
    except TransactionServiceException, ex:
6675 
      result.ex = ex
6676 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6677 
    result.write(oprot)
6678 
    oprot.writeMessageEnd()
6679 
    oprot.trans.flush()
1886 ankur.sing 6680 
 
4712 rajveer 6681 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6682 
    args = markOrderAsDelivered_args()
6683 
    args.read(iprot)
6684 
    iprot.readMessageEnd()
6685 
    result = markOrderAsDelivered_result()
6686 
    try:
6687 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6688 
    except TransactionServiceException, ex:
6689 
      result.ex = ex
6690 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6691 
    result.write(oprot)
6692 
    oprot.writeMessageEnd()
6693 
    oprot.trans.flush()
6694 
 
5553 rajveer 6695 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6696 
    args = markOrderAsReceivedAtStore_args()
6697 
    args.read(iprot)
6698 
    iprot.readMessageEnd()
6699 
    result = markOrderAsReceivedAtStore_result()
6700 
    try:
6701 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6702 
    except TransactionServiceException, ex:
6703 
      result.ex = ex
6704 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6705 
    result.write(oprot)
6706 
    oprot.writeMessageEnd()
6707 
    oprot.trans.flush()
6708 
 
4454 rajveer 6709 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6710 
    args = markOrderDoaRequestReceived_args()
6711 
    args.read(iprot)
6712 
    iprot.readMessageEnd()
6713 
    result = markOrderDoaRequestReceived_result()
6714 
    try:
6715 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6716 
    except TransactionServiceException, ex:
6717 
      result.ex = ex
6718 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6719 
    result.write(oprot)
6720 
    oprot.writeMessageEnd()
6721 
    oprot.trans.flush()
6722 
 
6723 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6724 
    args = markOrderDoaRequestAuthorized_args()
6725 
    args.read(iprot)
6726 
    iprot.readMessageEnd()
6727 
    result = markOrderDoaRequestAuthorized_result()
6728 
    try:
6729 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6730 
    except TransactionServiceException, ex:
6731 
      result.ex = ex
6732 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6733 
    result.write(oprot)
6734 
    oprot.writeMessageEnd()
6735 
    oprot.trans.flush()
6736 
 
4488 rajveer 6737 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6738 
    args = markOrderReturnRequestReceived_args()
6739 
    args.read(iprot)
6740 
    iprot.readMessageEnd()
6741 
    result = markOrderReturnRequestReceived_result()
6742 
    try:
6743 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6744 
    except TransactionServiceException, ex:
6745 
      result.ex = ex
6746 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6747 
    result.write(oprot)
6748 
    oprot.writeMessageEnd()
6749 
    oprot.trans.flush()
6750 
 
6751 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6752 
    args = markOrderReturnRequestAuthorized_args()
6753 
    args.read(iprot)
6754 
    iprot.readMessageEnd()
6755 
    result = markOrderReturnRequestAuthorized_result()
6756 
    try:
6757 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6758 
    except TransactionServiceException, ex:
6759 
      result.ex = ex
6760 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6761 
    result.write(oprot)
6762 
    oprot.writeMessageEnd()
6763 
    oprot.trans.flush()
6764 
 
2536 chandransh 6765 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6766 
    args = requestPickupNumber_args()
6767 
    args.read(iprot)
6768 
    iprot.readMessageEnd()
6769 
    result = requestPickupNumber_result()
6770 
    try:
4579 rajveer 6771 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6772 
    except TransactionServiceException, ex:
6773 
      result.ex = ex
6774 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6775 
    result.write(oprot)
6776 
    oprot.writeMessageEnd()
6777 
    oprot.trans.flush()
6778 
 
6779 
  def process_authorizePickup(self, seqid, iprot, oprot):
6780 
    args = authorizePickup_args()
6781 
    args.read(iprot)
6782 
    iprot.readMessageEnd()
6783 
    result = authorizePickup_result()
6784 
    try:
4602 rajveer 6785 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6786 
    except TransactionServiceException, ex:
6787 
      result.ex = ex
6788 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6789 
    result.write(oprot)
6790 
    oprot.writeMessageEnd()
6791 
    oprot.trans.flush()
6792 
 
2764 chandransh 6793 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6794 
    args = markDoasAsPickedUp_args()
6795 
    args.read(iprot)
6796 
    iprot.readMessageEnd()
6797 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6798 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6799 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6800 
    result.write(oprot)
6801 
    oprot.writeMessageEnd()
6802 
    oprot.trans.flush()
6803 
 
4910 phani.kuma 6804 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6805 
    args = getDoasNotPickedUp_args()
6806 
    args.read(iprot)
6807 
    iprot.readMessageEnd()
6808 
    result = getDoasNotPickedUp_result()
6809 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6810 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6811 
    result.write(oprot)
6812 
    oprot.writeMessageEnd()
6813 
    oprot.trans.flush()
6814 
 
4741 phani.kuma 6815 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6816 
    args = markReturnOrdersAsPickedUp_args()
6817 
    args.read(iprot)
6818 
    iprot.readMessageEnd()
6819 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6820 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6821 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6822 
    result.write(oprot)
6823 
    oprot.writeMessageEnd()
6824 
    oprot.trans.flush()
6825 
 
4910 phani.kuma 6826 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6827 
    args = getReturnOrdersNotPickedUp_args()
6828 
    args.read(iprot)
6829 
    iprot.readMessageEnd()
6830 
    result = getReturnOrdersNotPickedUp_result()
6831 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6832 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6833 
    result.write(oprot)
6834 
    oprot.writeMessageEnd()
6835 
    oprot.trans.flush()
6836 
 
2616 chandransh 6837 
  def process_receiveReturn(self, seqid, iprot, oprot):
6838 
    args = receiveReturn_args()
2591 chandransh 6839 
    args.read(iprot)
6840 
    iprot.readMessageEnd()
2616 chandransh 6841 
    result = receiveReturn_result()
2591 chandransh 6842 
    try:
4479 rajveer 6843 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6844 
    except TransactionServiceException, ex:
6845 
      result.ex = ex
2616 chandransh 6846 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6847 
    result.write(oprot)
6848 
    oprot.writeMessageEnd()
6849 
    oprot.trans.flush()
2536 chandransh 6850 
 
2591 chandransh 6851 
  def process_validateDoa(self, seqid, iprot, oprot):
6852 
    args = validateDoa_args()
6853 
    args.read(iprot)
6854 
    iprot.readMessageEnd()
6855 
    result = validateDoa_result()
6856 
    try:
6857 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6858 
    except TransactionServiceException, ex:
6859 
      result.ex = ex
6860 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6861 
    result.write(oprot)
6862 
    oprot.writeMessageEnd()
6863 
    oprot.trans.flush()
6864 
 
4495 rajveer 6865 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6866 
    args = validateReturnProduct_args()
6867 
    args.read(iprot)
6868 
    iprot.readMessageEnd()
6869 
    result = validateReturnProduct_result()
6870 
    try:
6871 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6872 
    except TransactionServiceException, ex:
6873 
      result.ex = ex
6874 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6875 
    result.write(oprot)
6876 
    oprot.writeMessageEnd()
6877 
    oprot.trans.flush()
6878 
 
2616 chandransh 6879 
  def process_reshipOrder(self, seqid, iprot, oprot):
6880 
    args = reshipOrder_args()
6881 
    args.read(iprot)
6882 
    iprot.readMessageEnd()
6883 
    result = reshipOrder_result()
6884 
    try:
6885 
      result.success = self._handler.reshipOrder(args.orderId)
6886 
    except TransactionServiceException, ex:
6887 
      result.ex = ex
6888 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6889 
    result.write(oprot)
6890 
    oprot.writeMessageEnd()
6891 
    oprot.trans.flush()
2591 chandransh 6892 
 
2616 chandransh 6893 
  def process_refundOrder(self, seqid, iprot, oprot):
6894 
    args = refundOrder_args()
6895 
    args.read(iprot)
6896 
    iprot.readMessageEnd()
6897 
    result = refundOrder_result()
6898 
    try:
3226 chandransh 6899 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6900 
    except TransactionServiceException, ex:
6901 
      result.ex = ex
6902 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6903 
    result.write(oprot)
6904 
    oprot.writeMessageEnd()
6905 
    oprot.trans.flush()
6906 
 
2690 chandransh 6907 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6908 
    args = getReturnOrders_args()
6909 
    args.read(iprot)
6910 
    iprot.readMessageEnd()
6911 
    result = getReturnOrders_result()
6912 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6913 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6914 
    result.write(oprot)
6915 
    oprot.writeMessageEnd()
6916 
    oprot.trans.flush()
2616 chandransh 6917 
 
5481 phani.kuma 6918 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6919 
    args = getAllReturnOrders_args()
6920 
    args.read(iprot)
6921 
    iprot.readMessageEnd()
6922 
    result = getAllReturnOrders_result()
6923 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6924 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6925 
    result.write(oprot)
6926 
    oprot.writeMessageEnd()
6927 
    oprot.trans.flush()
6928 
 
2700 chandransh 6929 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6930 
    args = getReturnOrder_args()
6931 
    args.read(iprot)
6932 
    iprot.readMessageEnd()
6933 
    result = getReturnOrder_result()
6934 
    try:
6935 
      result.success = self._handler.getReturnOrder(args.id)
6936 
    except TransactionServiceException, ex:
6937 
      result.ex = ex
6938 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6939 
    result.write(oprot)
6940 
    oprot.writeMessageEnd()
6941 
    oprot.trans.flush()
6942 
 
2690 chandransh 6943 
  def process_processReturn(self, seqid, iprot, oprot):
6944 
    args = processReturn_args()
6945 
    args.read(iprot)
6946 
    iprot.readMessageEnd()
6947 
    result = processReturn_result()
6948 
    try:
6949 
      self._handler.processReturn(args.returnOrderId)
6950 
    except TransactionServiceException, ex:
6951 
      result.ex = ex
6952 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6953 
    result.write(oprot)
6954 
    oprot.writeMessageEnd()
6955 
    oprot.trans.flush()
6956 
 
3451 chandransh 6957 
  def process_updateWeight(self, seqid, iprot, oprot):
6958 
    args = updateWeight_args()
6959 
    args.read(iprot)
6960 
    iprot.readMessageEnd()
6961 
    result = updateWeight_result()
6962 
    try:
6963 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6964 
    except TransactionServiceException, ex:
6965 
      result.ex = ex
6966 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6967 
    result.write(oprot)
6968 
    oprot.writeMessageEnd()
6969 
    oprot.trans.flush()
2819 chandransh 6970 
 
3469 chandransh 6971 
  def process_changeItem(self, seqid, iprot, oprot):
6972 
    args = changeItem_args()
6973 
    args.read(iprot)
6974 
    iprot.readMessageEnd()
6975 
    result = changeItem_result()
6976 
    try:
6977 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6978 
    except TransactionServiceException, ex:
6979 
      result.ex = ex
6980 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6981 
    result.write(oprot)
6982 
    oprot.writeMessageEnd()
6983 
    oprot.trans.flush()
3451 chandransh 6984 
 
3469 chandransh 6985 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6986 
    args = shiftToWarehouse_args()
6987 
    args.read(iprot)
6988 
    iprot.readMessageEnd()
6989 
    result = shiftToWarehouse_result()
6990 
    try:
6991 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6992 
    except TransactionServiceException, ex:
6993 
      result.ex = ex
6994 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6995 
    result.write(oprot)
6996 
    oprot.writeMessageEnd()
6997 
    oprot.trans.flush()
6998 
 
3553 chandransh 6999 
  def process_addDelayReason(self, seqid, iprot, oprot):
7000 
    args = addDelayReason_args()
7001 
    args.read(iprot)
7002 
    iprot.readMessageEnd()
7003 
    result = addDelayReason_result()
7004 
    try:
4647 rajveer 7005 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7006 
    except TransactionServiceException, ex:
7007 
      result.ex = ex
7008 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7009 
    result.write(oprot)
7010 
    oprot.writeMessageEnd()
7011 
    oprot.trans.flush()
3469 chandransh 7012 
 
3956 chandransh 7013 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7014 
    args = reconcileCodCollection_args()
7015 
    args.read(iprot)
7016 
    iprot.readMessageEnd()
7017 
    result = reconcileCodCollection_result()
7018 
    try:
7019 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7020 
    except TransactionServiceException, ex:
7021 
      result.ex = ex
7022 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7023 
    result.write(oprot)
7024 
    oprot.writeMessageEnd()
7025 
    oprot.trans.flush()
3553 chandransh 7026 
 
4008 mandeep.dh 7027 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7028 
    args = getTransactionsRequiringExtraProcessing_args()
7029 
    args.read(iprot)
7030 
    iprot.readMessageEnd()
7031 
    result = getTransactionsRequiringExtraProcessing_result()
7032 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7033 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7034 
    result.write(oprot)
7035 
    oprot.writeMessageEnd()
7036 
    oprot.trans.flush()
3956 chandransh 7037 
 
4008 mandeep.dh 7038 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7039 
    args = markTransactionAsProcessed_args()
7040 
    args.read(iprot)
7041 
    iprot.readMessageEnd()
7042 
    result = markTransactionAsProcessed_result()
7043 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7044 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7045 
    result.write(oprot)
7046 
    oprot.writeMessageEnd()
7047 
    oprot.trans.flush()
7048 
 
4018 chandransh 7049 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7050 
    args = getItemWiseRiskyOrdersCount_args()
7051 
    args.read(iprot)
7052 
    iprot.readMessageEnd()
7053 
    result = getItemWiseRiskyOrdersCount_result()
7054 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7055 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7056 
    result.write(oprot)
7057 
    oprot.writeMessageEnd()
7058 
    oprot.trans.flush()
4008 mandeep.dh 7059 
 
4295 varun.gupt 7060 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7061 
    args = getOrdersForItemIds_args()
7062 
    args.read(iprot)
7063 
    iprot.readMessageEnd()
7064 
    result = getOrdersForItemIds_result()
7065 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7066 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7067 
    result.write(oprot)
7068 
    oprot.writeMessageEnd()
7069 
    oprot.trans.flush()
7070 
 
4247 rajveer 7071 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7072 
    args = markOrderCancellationRequestReceived_args()
7073 
    args.read(iprot)
7074 
    iprot.readMessageEnd()
7075 
    result = markOrderCancellationRequestReceived_result()
7076 
    try:
7077 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7078 
    except TransactionServiceException, ex:
7079 
      result.ex = ex
7080 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7081 
    result.write(oprot)
7082 
    oprot.writeMessageEnd()
7083 
    oprot.trans.flush()
4018 chandransh 7084 
 
4247 rajveer 7085 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7086 
    args = markOrderCancellationRequestConfirmed_args()
7087 
    args.read(iprot)
7088 
    iprot.readMessageEnd()
7089 
    result = markOrderCancellationRequestConfirmed_result()
7090 
    try:
7091 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7092 
    except TransactionServiceException, ex:
7093 
      result.ex = ex
7094 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7095 
    result.write(oprot)
7096 
    oprot.writeMessageEnd()
7097 
    oprot.trans.flush()
7098 
 
7099 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7100 
    args = markOrderCancellationRequestDenied_args()
7101 
    args.read(iprot)
7102 
    iprot.readMessageEnd()
7103 
    result = markOrderCancellationRequestDenied_result()
7104 
    try:
7105 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7106 
    except TransactionServiceException, ex:
7107 
      result.ex = ex
7108 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7109 
    result.write(oprot)
7110 
    oprot.writeMessageEnd()
7111 
    oprot.trans.flush()
7112 
 
4258 rajveer 7113 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7114 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7115 
    args.read(iprot)
7116 
    iprot.readMessageEnd()
4258 rajveer 7117 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7118 
    try:
4258 rajveer 7119 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7120 
    except TransactionServiceException, ex:
7121 
      result.ex = ex
4258 rajveer 7122 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7123 
    result.write(oprot)
7124 
    oprot.writeMessageEnd()
7125 
    oprot.trans.flush()
7126 
 
4259 anupam.sin 7127 
  def process_refundTransaction(self, seqid, iprot, oprot):
7128 
    args = refundTransaction_args()
7129 
    args.read(iprot)
7130 
    iprot.readMessageEnd()
7131 
    result = refundTransaction_result()
7132 
    try:
7133 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7134 
    except TransactionServiceException, ex:
7135 
      result.ex = ex
7136 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7137 
    result.write(oprot)
7138 
    oprot.writeMessageEnd()
7139 
    oprot.trans.flush()
4247 rajveer 7140 
 
4324 mandeep.dh 7141 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7142 
    args = updateShipmentAddress_args()
7143 
    args.read(iprot)
7144 
    iprot.readMessageEnd()
7145 
    result = updateShipmentAddress_result()
7146 
    try:
7147 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7148 
    except TransactionServiceException, ex:
7149 
      result.ex = ex
7150 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7151 
    result.write(oprot)
7152 
    oprot.writeMessageEnd()
7153 
    oprot.trans.flush()
7154 
 
4285 rajveer 7155 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7156 
    args = acceptOrdersForItemId_args()
7157 
    args.read(iprot)
7158 
    iprot.readMessageEnd()
7159 
    result = acceptOrdersForItemId_result()
7160 
    try:
7161 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7162 
    except TransactionServiceException, ex:
7163 
      result.ex = ex
7164 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7165 
    result.write(oprot)
7166 
    oprot.writeMessageEnd()
7167 
    oprot.trans.flush()
4259 anupam.sin 7168 
 
4303 rajveer 7169 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7170 
    args = markOrdersAsPORaised_args()
7171 
    args.read(iprot)
7172 
    iprot.readMessageEnd()
7173 
    result = markOrdersAsPORaised_result()
7174 
    try:
4369 rajveer 7175 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7176 
    except TransactionServiceException, ex:
7177 
      result.ex = ex
7178 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7179 
    result.write(oprot)
7180 
    oprot.writeMessageEnd()
7181 
    oprot.trans.flush()
4285 rajveer 7182 
 
4303 rajveer 7183 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7184 
    args = markOrdersAsReversalInitiated_args()
7185 
    args.read(iprot)
7186 
    iprot.readMessageEnd()
7187 
    result = markOrdersAsReversalInitiated_result()
7188 
    try:
4369 rajveer 7189 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7190 
    except TransactionServiceException, ex:
7191 
      result.ex = ex
7192 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7193 
    result.write(oprot)
7194 
    oprot.writeMessageEnd()
7195 
    oprot.trans.flush()
7196 
 
7197 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7198 
    args = markOrdersAsNotAvailabke_args()
7199 
    args.read(iprot)
7200 
    iprot.readMessageEnd()
7201 
    result = markOrdersAsNotAvailabke_result()
7202 
    try:
4369 rajveer 7203 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7204 
    except TransactionServiceException, ex:
7205 
      result.ex = ex
7206 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7207 
    result.write(oprot)
7208 
    oprot.writeMessageEnd()
7209 
    oprot.trans.flush()
7210 
 
4369 rajveer 7211 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7212 
    args = markOrdersAsTimeout_args()
7213 
    args.read(iprot)
7214 
    iprot.readMessageEnd()
7215 
    result = markOrdersAsTimeout_result()
7216 
    try:
7217 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7218 
    except TransactionServiceException, ex:
7219 
      result.ex = ex
7220 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7221 
    result.write(oprot)
7222 
    oprot.writeMessageEnd()
7223 
    oprot.trans.flush()
4303 rajveer 7224 
 
4662 rajveer 7225 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7226 
    args = markOrderAsLostInTransit_args()
7227 
    args.read(iprot)
7228 
    iprot.readMessageEnd()
7229 
    result = markOrderAsLostInTransit_result()
7230 
    try:
7231 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7232 
    except TransactionServiceException, ex:
7233 
      result.ex = ex
7234 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7235 
    result.write(oprot)
7236 
    oprot.writeMessageEnd()
7237 
    oprot.trans.flush()
7238 
 
4386 anupam.sin 7239 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7240 
    args = getOrderForAwb_args()
7241 
    args.read(iprot)
7242 
    iprot.readMessageEnd()
7243 
    result = getOrderForAwb_result()
7244 
    try:
7245 
      result.success = self._handler.getOrderForAwb(args.awb)
7246 
    except TransactionServiceException, ex:
7247 
      result.ex = ex
7248 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7249 
    result.write(oprot)
7250 
    oprot.writeMessageEnd()
7251 
    oprot.trans.flush()
4369 rajveer 7252 
 
4506 phani.kuma 7253 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7254 
    args = getOrdersForProviderForStatus_args()
7255 
    args.read(iprot)
7256 
    iprot.readMessageEnd()
7257 
    result = getOrdersForProviderForStatus_result()
7258 
    try:
4910 phani.kuma 7259 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7260 
    except TransactionServiceException, ex:
7261 
      result.ex = ex
7262 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7263 
    result.write(oprot)
7264 
    oprot.writeMessageEnd()
7265 
    oprot.trans.flush()
4386 anupam.sin 7266 
 
4600 varun.gupt 7267 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7268 
    args = getBilledOrdersForVendor_args()
7269 
    args.read(iprot)
7270 
    iprot.readMessageEnd()
7271 
    result = getBilledOrdersForVendor_result()
7272 
    try:
7273 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7274 
    except TransactionServiceException, ex:
7275 
      result.ex = ex
7276 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7277 
    result.write(oprot)
7278 
    oprot.writeMessageEnd()
7279 
    oprot.trans.flush()
4506 phani.kuma 7280 
 
4607 rajveer 7281 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7282 
    args = getSlippedSippingDateOrders_args()
7283 
    args.read(iprot)
7284 
    iprot.readMessageEnd()
7285 
    result = getSlippedSippingDateOrders_result()
7286 
    try:
7287 
      result.success = self._handler.getSlippedSippingDateOrders()
7288 
    except TransactionServiceException, ex:
7289 
      result.ex = ex
7290 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7291 
    result.write(oprot)
7292 
    oprot.writeMessageEnd()
7293 
    oprot.trans.flush()
7294 
 
4709 rajveer 7295 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7296 
    args = getCancelledOrders_args()
7297 
    args.read(iprot)
7298 
    iprot.readMessageEnd()
7299 
    result = getCancelledOrders_result()
7300 
    try:
7301 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7302 
    except TransactionServiceException, ex:
7303 
      result.ex = ex
7304 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7305 
    result.write(oprot)
7306 
    oprot.writeMessageEnd()
7307 
    oprot.trans.flush()
7308 
 
4600 varun.gupt 7309 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7310 
    args = saveBluedartSettlements_args()
7311 
    args.read(iprot)
7312 
    iprot.readMessageEnd()
7313 
    result = saveBluedartSettlements_result()
7314 
    try:
7315 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7316 
    except TransactionServiceException, ex:
7317 
      result.ex = ex
7318 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7319 
    result.write(oprot)
7320 
    oprot.writeMessageEnd()
7321 
    oprot.trans.flush()
7322 
 
7323 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7324 
    args = savePaymentSettlements_args()
7325 
    args.read(iprot)
7326 
    iprot.readMessageEnd()
7327 
    result = savePaymentSettlements_result()
7328 
    try:
4905 varun.gupt 7329 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7330 
    except TransactionServiceException, ex:
7331 
      result.ex = ex
7332 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7336 
 
7337 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7338 
    args = saveEBSSettlementSummary_args()
7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
7341 
    result = saveEBSSettlementSummary_result()
7342 
    try:
7343 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7344 
    except TransactionServiceException, ex:
7345 
      result.ex = ex
7346 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
7350 
 
5386 phani.kuma 7351 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7352 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
5386 phani.kuma 7355 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7356 
    try:
5386 phani.kuma 7357 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7358 
    except TransactionServiceException, ex:
7359 
      result.ex = ex
5386 phani.kuma 7360 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7361 
    result.write(oprot)
7362 
    oprot.writeMessageEnd()
7363 
    oprot.trans.flush()
7364 
 
5386 phani.kuma 7365 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7366 
    args = getSettlementForCod_args()
7367 
    args.read(iprot)
7368 
    iprot.readMessageEnd()
7369 
    result = getSettlementForCod_result()
7370 
    try:
7371 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7372 
    except TransactionServiceException, ex:
7373 
      result.ex = ex
7374 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
4600 varun.gupt 7379 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7380 
    args = getEBSSettlementSummaries_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = getEBSSettlementSummaries_result()
7384 
    try:
7385 
      result.success = self._handler.getEBSSettlementSummaries()
7386 
    except TransactionServiceException, ex:
7387 
      result.ex = ex
7388 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7389 
    result.write(oprot)
7390 
    oprot.writeMessageEnd()
7391 
    oprot.trans.flush()
7392 
 
7393 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7394 
    args = markEBSSettlementUploaded_args()
7395 
    args.read(iprot)
7396 
    iprot.readMessageEnd()
7397 
    result = markEBSSettlementUploaded_result()
7398 
    try:
7399 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7400 
    except TransactionServiceException, ex:
7401 
      result.ex = ex
7402 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
7407 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7408 
    args = getEBSSettlementDate_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = getEBSSettlementDate_result()
7412 
    try:
7413 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7414 
    except TransactionServiceException, ex:
7415 
      result.ex = ex
7416 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
4715 varun.gupt 7421 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7422 
    args = getSettlementsByDate_args()
7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
7425 
    result = getSettlementsByDate_result()
7426 
    try:
7427 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7428 
    except TransactionServiceException, ex:
7429 
      result.ex = ex
7430 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
4600 varun.gupt 7434 
 
4715 varun.gupt 7435 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7436 
    args = getReshippedOrderIds_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = getReshippedOrderIds_result()
7440 
    try:
7441 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7442 
    except TransactionServiceException, ex:
7443 
      result.ex = ex
7444 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7445 
    result.write(oprot)
7446 
    oprot.writeMessageEnd()
7447 
    oprot.trans.flush()
7448 
 
5481 phani.kuma 7449 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7450 
    args = getBilledOrders_args()
4875 varun.gupt 7451 
    args.read(iprot)
7452 
    iprot.readMessageEnd()
5481 phani.kuma 7453 
    result = getBilledOrders_result()
4875 varun.gupt 7454 
    try:
5481 phani.kuma 7455 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7456 
    except TransactionServiceException, ex:
7457 
      result.ex = ex
5481 phani.kuma 7458 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
4757 mandeep.dh 7462 
 
5031 varun.gupt 7463 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7464 
    args = getStatusDistributionOfOrders_args()
7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
7467 
    result = getStatusDistributionOfOrders_result()
7468 
    try:
7469 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7470 
    except TransactionServiceException, ex:
7471 
      result.ex = ex
7472 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7473 
    result.write(oprot)
7474 
    oprot.writeMessageEnd()
7475 
    oprot.trans.flush()
4875 varun.gupt 7476 
 
5067 varun.gupt 7477 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7478 
    args = getOrderIdsForStatus_args()
7479 
    args.read(iprot)
7480 
    iprot.readMessageEnd()
7481 
    result = getOrderIdsForStatus_result()
7482 
    try:
7483 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7484 
    except TransactionServiceException, ex:
7485 
      result.ex = ex
7486 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7487 
    result.write(oprot)
7488 
    oprot.writeMessageEnd()
7489 
    oprot.trans.flush()
5031 varun.gupt 7490 
 
5348 anupam.sin 7491 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7492 
    args = updateCODAgent_args()
7493 
    args.read(iprot)
7494 
    iprot.readMessageEnd()
7495 
    result = updateCODAgent_result()
7496 
    try:
7497 
      self._handler.updateCODAgent(args.agent, args.orderId)
7498 
    except TransactionServiceException, ex:
7499 
      result.ex = ex
7500 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7501 
    result.write(oprot)
7502 
    oprot.writeMessageEnd()
7503 
    oprot.trans.flush()
7504 
 
5099 varun.gupt 7505 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7506 
    args = updateOrderAsPaidToVendor_args()
7507 
    args.read(iprot)
7508 
    iprot.readMessageEnd()
7509 
    result = updateOrderAsPaidToVendor_result()
7510 
    try:
7511 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7512 
    except TransactionServiceException, ex:
7513 
      result.ex = ex
7514 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7515 
    result.write(oprot)
7516 
    oprot.writeMessageEnd()
7517 
    oprot.trans.flush()
5067 varun.gupt 7518 
 
5386 phani.kuma 7519 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7520 
    args = updateOrderOnlyAsPaidToVendor_args()
7521 
    args.read(iprot)
7522 
    iprot.readMessageEnd()
7523 
    result = updateOrderOnlyAsPaidToVendor_result()
7524 
    try:
7525 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7526 
    except TransactionServiceException, ex:
7527 
      result.ex = ex
7528 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7529 
    result.write(oprot)
7530 
    oprot.writeMessageEnd()
7531 
    oprot.trans.flush()
7532 
 
5208 varun.gupt 7533 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7534 
    args = getRefundedOrdersMarkedPaid_args()
7535 
    args.read(iprot)
7536 
    iprot.readMessageEnd()
7537 
    result = getRefundedOrdersMarkedPaid_result()
7538 
    try:
7539 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7540 
    except TransactionServiceException, ex:
7541 
      result.ex = ex
7542 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7543 
    result.write(oprot)
7544 
    oprot.writeMessageEnd()
7545 
    oprot.trans.flush()
5099 varun.gupt 7546 
 
5447 anupam.sin 7547 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7548 
    args = getAllVerificationAgents_args()
7549 
    args.read(iprot)
7550 
    iprot.readMessageEnd()
7551 
    result = getAllVerificationAgents_result()
7552 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7553 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7554 
    result.write(oprot)
7555 
    oprot.writeMessageEnd()
7556 
    oprot.trans.flush()
5208 varun.gupt 7557 
 
5527 anupam.sin 7558 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7559 
    args = getAllAttributesForOrderId_args()
7560 
    args.read(iprot)
7561 
    iprot.readMessageEnd()
7562 
    result = getAllAttributesForOrderId_result()
7563 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7564 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7565 
    result.write(oprot)
7566 
    oprot.writeMessageEnd()
7567 
    oprot.trans.flush()
5447 anupam.sin 7568 
 
5676 rajveer 7569 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7570 
    args = setOrderAttributes_args()
7571 
    args.read(iprot)
7572 
    iprot.readMessageEnd()
7573 
    result = setOrderAttributes_result()
7574 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7575 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
5527 anupam.sin 7580 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7581 
    args = setOrderAttributeForTransaction_args()
7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
7584 
    result = setOrderAttributeForTransaction_result()
7585 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7586 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
5553 rajveer 7591 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7592 
    args = getReceivePendingOrders_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = getReceivePendingOrders_result()
7596 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7597 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
5527 anupam.sin 7601 
 
5553 rajveer 7602 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7603 
    args = getReceivedAtStoreOrders_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = getReceivedAtStoreOrders_result()
7607 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7608 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
5713 rajveer 7613 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7614 
    args = getOrdersCollectionAtStore_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = getOrdersCollectionAtStore_result()
7618 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7619 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
7623 
 
5833 rajveer 7624 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7625 
    args = getOrderAttributeValue_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = getOrderAttributeValue_result()
7629 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7630 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
5593 mandeep.dh 7635 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7636 
    args = acceptOrderForItem_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = acceptOrderForItem_result()
7640 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7641 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
5553 rajveer 7645 
 
6000 mandeep.dh 7646 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
7647 
    args = createRechargeOrder_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = createRechargeOrder_result()
7651 
    try:
7652 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
7653 
    except TransactionServiceException, ex:
7654 
      result.ex = ex
7655 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
5593 mandeep.dh 7659 
 
6000 mandeep.dh 7660 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
7661 
    args = updateRechargeOrderStatus_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = updateRechargeOrderStatus_result()
7665 
    try:
7666 
      self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
7667 
    except TransactionServiceException, ex:
7668 
      result.ex = ex
7669 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
7674 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
7675 
    args = activateRechargeTxn_args()
7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
7678 
    result = activateRechargeTxn_result()
7679 
    try:
7680 
      result.success = self._handler.activateRechargeTxn(args.rechargeCoupons)
7681 
    except TransactionServiceException, ex:
7682 
      result.ex = ex
7683 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
7687 
 
7688 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
7689 
    args = getRechargeOrders_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = getRechargeOrders_result()
7693 
    result.success = self._handler.getRechargeOrders(args.customerId)
7694 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
7695 
    result.write(oprot)
7696 
    oprot.writeMessageEnd()
7697 
    oprot.trans.flush()
7698 
 
7699 
  def process_getRechargeCoupons(self, seqid, iprot, oprot):
7700 
    args = getRechargeCoupons_args()
7701 
    args.read(iprot)
7702 
    iprot.readMessageEnd()
7703 
    result = getRechargeCoupons_result()
7704 
    result.success = self._handler.getRechargeCoupons(args.customerId, args.rechargeCouponStatus)
7705 
    oprot.writeMessageBegin("getRechargeCoupons", TMessageType.REPLY, seqid)
7706 
    result.write(oprot)
7707 
    oprot.writeMessageEnd()
7708 
    oprot.trans.flush()
7709 
 
7710 
 
94 ashish 7711 
# HELPER FUNCTIONS AND STRUCTURES
7712 
 
7713 
class createTransaction_args:
7714 
  """
7715 
  Attributes:
7716 
   - transaction
7717 
  """
7718 
 
7719 
  thrift_spec = (
7720 
    None, # 0
7721 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7722 
  )
7723 
 
7724 
  def __init__(self, transaction=None,):
7725 
    self.transaction = transaction
7726 
 
7727 
  def read(self, iprot):
7728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7730 
      return
7731 
    iprot.readStructBegin()
7732 
    while True:
7733 
      (fname, ftype, fid) = iprot.readFieldBegin()
7734 
      if ftype == TType.STOP:
7735 
        break
7736 
      if fid == 1:
7737 
        if ftype == TType.STRUCT:
7738 
          self.transaction = Transaction()
7739 
          self.transaction.read(iprot)
7740 
        else:
7741 
          iprot.skip(ftype)
7742 
      else:
7743 
        iprot.skip(ftype)
7744 
      iprot.readFieldEnd()
7745 
    iprot.readStructEnd()
7746 
 
7747 
  def write(self, oprot):
7748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7750 
      return
7751 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7752 
    if self.transaction is not None:
94 ashish 7753 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7754 
      self.transaction.write(oprot)
7755 
      oprot.writeFieldEnd()
7756 
    oprot.writeFieldStop()
7757 
    oprot.writeStructEnd()
7758 
 
3431 rajveer 7759 
  def validate(self):
7760 
    return
7761 
 
7762 
 
94 ashish 7763 
  def __repr__(self):
7764 
    L = ['%s=%r' % (key, value)
7765 
      for key, value in self.__dict__.iteritems()]
7766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7767 
 
7768 
  def __eq__(self, other):
7769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7770 
 
7771 
  def __ne__(self, other):
7772 
    return not (self == other)
7773 
 
7774 
class createTransaction_result:
7775 
  """
7776 
  Attributes:
132 ashish 7777 
   - success
94 ashish 7778 
   - ex
7779 
  """
7780 
 
7781 
  thrift_spec = (
132 ashish 7782 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7784 
  )
7785 
 
132 ashish 7786 
  def __init__(self, success=None, ex=None,):
7787 
    self.success = success
94 ashish 7788 
    self.ex = ex
7789 
 
7790 
  def read(self, iprot):
7791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7793 
      return
7794 
    iprot.readStructBegin()
7795 
    while True:
7796 
      (fname, ftype, fid) = iprot.readFieldBegin()
7797 
      if ftype == TType.STOP:
7798 
        break
132 ashish 7799 
      if fid == 0:
7800 
        if ftype == TType.I64:
7801 
          self.success = iprot.readI64();
7802 
        else:
7803 
          iprot.skip(ftype)
7804 
      elif fid == 1:
94 ashish 7805 
        if ftype == TType.STRUCT:
7806 
          self.ex = TransactionServiceException()
7807 
          self.ex.read(iprot)
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
7819 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7820 
    if self.success is not None:
132 ashish 7821 
      oprot.writeFieldBegin('success', TType.I64, 0)
7822 
      oprot.writeI64(self.success)
7823 
      oprot.writeFieldEnd()
3431 rajveer 7824 
    if self.ex is not None:
94 ashish 7825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7826 
      self.ex.write(oprot)
7827 
      oprot.writeFieldEnd()
7828 
    oprot.writeFieldStop()
7829 
    oprot.writeStructEnd()
7830 
 
3431 rajveer 7831 
  def validate(self):
7832 
    return
7833 
 
7834 
 
94 ashish 7835 
  def __repr__(self):
7836 
    L = ['%s=%r' % (key, value)
7837 
      for key, value in self.__dict__.iteritems()]
7838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7839 
 
7840 
  def __eq__(self, other):
7841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7842 
 
7843 
  def __ne__(self, other):
7844 
    return not (self == other)
7845 
 
7846 
class getTransaction_args:
7847 
  """
7848 
  Attributes:
7849 
   - id
7850 
  """
7851 
 
7852 
  thrift_spec = (
7853 
    None, # 0
7854 
    (1, TType.I64, 'id', None, None, ), # 1
7855 
  )
7856 
 
7857 
  def __init__(self, id=None,):
7858 
    self.id = id
7859 
 
7860 
  def read(self, iprot):
7861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7863 
      return
7864 
    iprot.readStructBegin()
7865 
    while True:
7866 
      (fname, ftype, fid) = iprot.readFieldBegin()
7867 
      if ftype == TType.STOP:
7868 
        break
7869 
      if fid == 1:
7870 
        if ftype == TType.I64:
7871 
          self.id = iprot.readI64();
7872 
        else:
7873 
          iprot.skip(ftype)
7874 
      else:
7875 
        iprot.skip(ftype)
7876 
      iprot.readFieldEnd()
7877 
    iprot.readStructEnd()
7878 
 
7879 
  def write(self, oprot):
7880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7882 
      return
7883 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7884 
    if self.id is not None:
94 ashish 7885 
      oprot.writeFieldBegin('id', TType.I64, 1)
7886 
      oprot.writeI64(self.id)
7887 
      oprot.writeFieldEnd()
7888 
    oprot.writeFieldStop()
7889 
    oprot.writeStructEnd()
7890 
 
3431 rajveer 7891 
  def validate(self):
7892 
    return
7893 
 
7894 
 
94 ashish 7895 
  def __repr__(self):
7896 
    L = ['%s=%r' % (key, value)
7897 
      for key, value in self.__dict__.iteritems()]
7898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7899 
 
7900 
  def __eq__(self, other):
7901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7902 
 
7903 
  def __ne__(self, other):
7904 
    return not (self == other)
7905 
 
7906 
class getTransaction_result:
7907 
  """
7908 
  Attributes:
7909 
   - success
7910 
   - ex
7911 
  """
7912 
 
7913 
  thrift_spec = (
7914 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7916 
  )
7917 
 
7918 
  def __init__(self, success=None, ex=None,):
7919 
    self.success = success
7920 
    self.ex = ex
7921 
 
7922 
  def read(self, iprot):
7923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7925 
      return
7926 
    iprot.readStructBegin()
7927 
    while True:
7928 
      (fname, ftype, fid) = iprot.readFieldBegin()
7929 
      if ftype == TType.STOP:
7930 
        break
7931 
      if fid == 0:
7932 
        if ftype == TType.STRUCT:
7933 
          self.success = Transaction()
7934 
          self.success.read(iprot)
7935 
        else:
7936 
          iprot.skip(ftype)
7937 
      elif fid == 1:
7938 
        if ftype == TType.STRUCT:
7939 
          self.ex = TransactionServiceException()
7940 
          self.ex.read(iprot)
7941 
        else:
7942 
          iprot.skip(ftype)
7943 
      else:
7944 
        iprot.skip(ftype)
7945 
      iprot.readFieldEnd()
7946 
    iprot.readStructEnd()
7947 
 
7948 
  def write(self, oprot):
7949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7951 
      return
7952 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7953 
    if self.success is not None:
94 ashish 7954 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7955 
      self.success.write(oprot)
7956 
      oprot.writeFieldEnd()
3431 rajveer 7957 
    if self.ex is not None:
94 ashish 7958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7959 
      self.ex.write(oprot)
7960 
      oprot.writeFieldEnd()
7961 
    oprot.writeFieldStop()
7962 
    oprot.writeStructEnd()
7963 
 
3431 rajveer 7964 
  def validate(self):
7965 
    return
7966 
 
7967 
 
94 ashish 7968 
  def __repr__(self):
7969 
    L = ['%s=%r' % (key, value)
7970 
      for key, value in self.__dict__.iteritems()]
7971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7972 
 
7973 
  def __eq__(self, other):
7974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7975 
 
7976 
  def __ne__(self, other):
7977 
    return not (self == other)
7978 
 
7979 
class getTransactionsForCustomer_args:
7980 
  """
7981 
  Attributes:
7982 
   - customerId
7983 
   - from_date
7984 
   - to_date
7985 
   - status
7986 
  """
7987 
 
7988 
  thrift_spec = (
7989 
    None, # 0
7990 
    (1, TType.I64, 'customerId', None, None, ), # 1
7991 
    (2, TType.I64, 'from_date', None, None, ), # 2
7992 
    (3, TType.I64, 'to_date', None, None, ), # 3
7993 
    (4, TType.I32, 'status', None, None, ), # 4
7994 
  )
7995 
 
7996 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7997 
    self.customerId = customerId
7998 
    self.from_date = from_date
7999 
    self.to_date = to_date
8000 
    self.status = status
8001 
 
8002 
  def read(self, iprot):
8003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8005 
      return
8006 
    iprot.readStructBegin()
8007 
    while True:
8008 
      (fname, ftype, fid) = iprot.readFieldBegin()
8009 
      if ftype == TType.STOP:
8010 
        break
8011 
      if fid == 1:
8012 
        if ftype == TType.I64:
8013 
          self.customerId = iprot.readI64();
8014 
        else:
8015 
          iprot.skip(ftype)
8016 
      elif fid == 2:
8017 
        if ftype == TType.I64:
8018 
          self.from_date = iprot.readI64();
8019 
        else:
8020 
          iprot.skip(ftype)
8021 
      elif fid == 3:
8022 
        if ftype == TType.I64:
8023 
          self.to_date = iprot.readI64();
8024 
        else:
8025 
          iprot.skip(ftype)
8026 
      elif fid == 4:
8027 
        if ftype == TType.I32:
8028 
          self.status = iprot.readI32();
8029 
        else:
8030 
          iprot.skip(ftype)
8031 
      else:
8032 
        iprot.skip(ftype)
8033 
      iprot.readFieldEnd()
8034 
    iprot.readStructEnd()
8035 
 
8036 
  def write(self, oprot):
8037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8039 
      return
8040 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8041 
    if self.customerId is not None:
94 ashish 8042 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8043 
      oprot.writeI64(self.customerId)
8044 
      oprot.writeFieldEnd()
3431 rajveer 8045 
    if self.from_date is not None:
94 ashish 8046 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8047 
      oprot.writeI64(self.from_date)
8048 
      oprot.writeFieldEnd()
3431 rajveer 8049 
    if self.to_date is not None:
94 ashish 8050 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8051 
      oprot.writeI64(self.to_date)
8052 
      oprot.writeFieldEnd()
3431 rajveer 8053 
    if self.status is not None:
94 ashish 8054 
      oprot.writeFieldBegin('status', TType.I32, 4)
8055 
      oprot.writeI32(self.status)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
3431 rajveer 8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
94 ashish 8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
8075 
class getTransactionsForCustomer_result:
8076 
  """
8077 
  Attributes:
8078 
   - success
8079 
   - ex
8080 
  """
8081 
 
8082 
  thrift_spec = (
8083 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8085 
  )
8086 
 
8087 
  def __init__(self, success=None, ex=None,):
8088 
    self.success = success
8089 
    self.ex = ex
8090 
 
8091 
  def read(self, iprot):
8092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8094 
      return
8095 
    iprot.readStructBegin()
8096 
    while True:
8097 
      (fname, ftype, fid) = iprot.readFieldBegin()
8098 
      if ftype == TType.STOP:
8099 
        break
8100 
      if fid == 0:
8101 
        if ftype == TType.LIST:
8102 
          self.success = []
6000 mandeep.dh 8103 
          (_etype73, _size70) = iprot.readListBegin()
8104 
          for _i74 in xrange(_size70):
8105 
            _elem75 = Transaction()
8106 
            _elem75.read(iprot)
8107 
            self.success.append(_elem75)
94 ashish 8108 
          iprot.readListEnd()
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      elif fid == 1:
8112 
        if ftype == TType.STRUCT:
8113 
          self.ex = TransactionServiceException()
8114 
          self.ex.read(iprot)
8115 
        else:
8116 
          iprot.skip(ftype)
8117 
      else:
8118 
        iprot.skip(ftype)
8119 
      iprot.readFieldEnd()
8120 
    iprot.readStructEnd()
8121 
 
8122 
  def write(self, oprot):
8123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8125 
      return
8126 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8127 
    if self.success is not None:
94 ashish 8128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 8130 
      for iter76 in self.success:
8131 
        iter76.write(oprot)
94 ashish 8132 
      oprot.writeListEnd()
8133 
      oprot.writeFieldEnd()
3431 rajveer 8134 
    if self.ex is not None:
94 ashish 8135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8136 
      self.ex.write(oprot)
8137 
      oprot.writeFieldEnd()
8138 
    oprot.writeFieldStop()
8139 
    oprot.writeStructEnd()
8140 
 
3431 rajveer 8141 
  def validate(self):
8142 
    return
8143 
 
8144 
 
94 ashish 8145 
  def __repr__(self):
8146 
    L = ['%s=%r' % (key, value)
8147 
      for key, value in self.__dict__.iteritems()]
8148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8149 
 
8150 
  def __eq__(self, other):
8151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8152 
 
8153 
  def __ne__(self, other):
8154 
    return not (self == other)
8155 
 
132 ashish 8156 
class getTransactionsForShoppingCartId_args:
8157 
  """
8158 
  Attributes:
8159 
   - shoppingCartId
8160 
  """
8161 
 
8162 
  thrift_spec = (
8163 
    None, # 0
8164 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8165 
  )
8166 
 
8167 
  def __init__(self, shoppingCartId=None,):
8168 
    self.shoppingCartId = shoppingCartId
8169 
 
8170 
  def read(self, iprot):
8171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8173 
      return
8174 
    iprot.readStructBegin()
8175 
    while True:
8176 
      (fname, ftype, fid) = iprot.readFieldBegin()
8177 
      if ftype == TType.STOP:
8178 
        break
8179 
      if fid == 1:
8180 
        if ftype == TType.I64:
8181 
          self.shoppingCartId = iprot.readI64();
8182 
        else:
8183 
          iprot.skip(ftype)
8184 
      else:
8185 
        iprot.skip(ftype)
8186 
      iprot.readFieldEnd()
8187 
    iprot.readStructEnd()
8188 
 
8189 
  def write(self, oprot):
8190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8192 
      return
8193 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8194 
    if self.shoppingCartId is not None:
132 ashish 8195 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8196 
      oprot.writeI64(self.shoppingCartId)
8197 
      oprot.writeFieldEnd()
8198 
    oprot.writeFieldStop()
8199 
    oprot.writeStructEnd()
8200 
 
3431 rajveer 8201 
  def validate(self):
8202 
    return
8203 
 
8204 
 
132 ashish 8205 
  def __repr__(self):
8206 
    L = ['%s=%r' % (key, value)
8207 
      for key, value in self.__dict__.iteritems()]
8208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8209 
 
8210 
  def __eq__(self, other):
8211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8212 
 
8213 
  def __ne__(self, other):
8214 
    return not (self == other)
8215 
 
8216 
class getTransactionsForShoppingCartId_result:
8217 
  """
8218 
  Attributes:
8219 
   - success
8220 
   - ex
8221 
  """
8222 
 
8223 
  thrift_spec = (
8224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8226 
  )
8227 
 
8228 
  def __init__(self, success=None, ex=None,):
8229 
    self.success = success
8230 
    self.ex = ex
8231 
 
8232 
  def read(self, iprot):
8233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8235 
      return
8236 
    iprot.readStructBegin()
8237 
    while True:
8238 
      (fname, ftype, fid) = iprot.readFieldBegin()
8239 
      if ftype == TType.STOP:
8240 
        break
8241 
      if fid == 0:
8242 
        if ftype == TType.LIST:
8243 
          self.success = []
6000 mandeep.dh 8244 
          (_etype80, _size77) = iprot.readListBegin()
8245 
          for _i81 in xrange(_size77):
8246 
            _elem82 = Transaction()
8247 
            _elem82.read(iprot)
8248 
            self.success.append(_elem82)
132 ashish 8249 
          iprot.readListEnd()
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      elif fid == 1:
8253 
        if ftype == TType.STRUCT:
8254 
          self.ex = TransactionServiceException()
8255 
          self.ex.read(iprot)
8256 
        else:
8257 
          iprot.skip(ftype)
8258 
      else:
8259 
        iprot.skip(ftype)
8260 
      iprot.readFieldEnd()
8261 
    iprot.readStructEnd()
8262 
 
8263 
  def write(self, oprot):
8264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8266 
      return
8267 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8268 
    if self.success is not None:
132 ashish 8269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 8271 
      for iter83 in self.success:
8272 
        iter83.write(oprot)
132 ashish 8273 
      oprot.writeListEnd()
8274 
      oprot.writeFieldEnd()
3431 rajveer 8275 
    if self.ex is not None:
132 ashish 8276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8277 
      self.ex.write(oprot)
8278 
      oprot.writeFieldEnd()
8279 
    oprot.writeFieldStop()
8280 
    oprot.writeStructEnd()
8281 
 
3431 rajveer 8282 
  def validate(self):
8283 
    return
8284 
 
8285 
 
132 ashish 8286 
  def __repr__(self):
8287 
    L = ['%s=%r' % (key, value)
8288 
      for key, value in self.__dict__.iteritems()]
8289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8290 
 
8291 
  def __eq__(self, other):
8292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8293 
 
8294 
  def __ne__(self, other):
8295 
    return not (self == other)
8296 
 
94 ashish 8297 
class getTransactionStatus_args:
8298 
  """
8299 
  Attributes:
8300 
   - transactionId
8301 
  """
8302 
 
8303 
  thrift_spec = (
8304 
    None, # 0
8305 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8306 
  )
8307 
 
8308 
  def __init__(self, transactionId=None,):
8309 
    self.transactionId = transactionId
8310 
 
8311 
  def read(self, iprot):
8312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8314 
      return
8315 
    iprot.readStructBegin()
8316 
    while True:
8317 
      (fname, ftype, fid) = iprot.readFieldBegin()
8318 
      if ftype == TType.STOP:
8319 
        break
8320 
      if fid == 1:
8321 
        if ftype == TType.I64:
8322 
          self.transactionId = iprot.readI64();
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      else:
8326 
        iprot.skip(ftype)
8327 
      iprot.readFieldEnd()
8328 
    iprot.readStructEnd()
8329 
 
8330 
  def write(self, oprot):
8331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8333 
      return
8334 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8335 
    if self.transactionId is not None:
94 ashish 8336 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8337 
      oprot.writeI64(self.transactionId)
8338 
      oprot.writeFieldEnd()
8339 
    oprot.writeFieldStop()
8340 
    oprot.writeStructEnd()
8341 
 
3431 rajveer 8342 
  def validate(self):
8343 
    return
8344 
 
8345 
 
94 ashish 8346 
  def __repr__(self):
8347 
    L = ['%s=%r' % (key, value)
8348 
      for key, value in self.__dict__.iteritems()]
8349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8350 
 
8351 
  def __eq__(self, other):
8352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8353 
 
8354 
  def __ne__(self, other):
8355 
    return not (self == other)
8356 
 
8357 
class getTransactionStatus_result:
8358 
  """
8359 
  Attributes:
8360 
   - success
8361 
   - ex
8362 
  """
8363 
 
8364 
  thrift_spec = (
8365 
    (0, TType.I32, 'success', None, None, ), # 0
8366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8367 
  )
8368 
 
8369 
  def __init__(self, success=None, ex=None,):
8370 
    self.success = success
8371 
    self.ex = ex
8372 
 
8373 
  def read(self, iprot):
8374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8376 
      return
8377 
    iprot.readStructBegin()
8378 
    while True:
8379 
      (fname, ftype, fid) = iprot.readFieldBegin()
8380 
      if ftype == TType.STOP:
8381 
        break
8382 
      if fid == 0:
8383 
        if ftype == TType.I32:
8384 
          self.success = iprot.readI32();
8385 
        else:
8386 
          iprot.skip(ftype)
8387 
      elif fid == 1:
8388 
        if ftype == TType.STRUCT:
8389 
          self.ex = TransactionServiceException()
8390 
          self.ex.read(iprot)
8391 
        else:
8392 
          iprot.skip(ftype)
8393 
      else:
8394 
        iprot.skip(ftype)
8395 
      iprot.readFieldEnd()
8396 
    iprot.readStructEnd()
8397 
 
8398 
  def write(self, oprot):
8399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8401 
      return
8402 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8403 
    if self.success is not None:
94 ashish 8404 
      oprot.writeFieldBegin('success', TType.I32, 0)
8405 
      oprot.writeI32(self.success)
8406 
      oprot.writeFieldEnd()
3431 rajveer 8407 
    if self.ex is not None:
94 ashish 8408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8409 
      self.ex.write(oprot)
8410 
      oprot.writeFieldEnd()
8411 
    oprot.writeFieldStop()
8412 
    oprot.writeStructEnd()
8413 
 
3431 rajveer 8414 
  def validate(self):
8415 
    return
8416 
 
8417 
 
94 ashish 8418 
  def __repr__(self):
8419 
    L = ['%s=%r' % (key, value)
8420 
      for key, value in self.__dict__.iteritems()]
8421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8422 
 
8423 
  def __eq__(self, other):
8424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8425 
 
8426 
  def __ne__(self, other):
8427 
    return not (self == other)
8428 
 
8429 
class changeTransactionStatus_args:
8430 
  """
8431 
  Attributes:
8432 
   - transactionId
8433 
   - status
8434 
   - description
5527 anupam.sin 8435 
   - pickUp
8436 
   - orderType
94 ashish 8437 
  """
8438 
 
8439 
  thrift_spec = (
8440 
    None, # 0
8441 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8442 
    (2, TType.I32, 'status', None, None, ), # 2
8443 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8444 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8445 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8446 
  )
8447 
 
5527 anupam.sin 8448 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8449 
    self.transactionId = transactionId
8450 
    self.status = status
8451 
    self.description = description
5527 anupam.sin 8452 
    self.pickUp = pickUp
8453 
    self.orderType = orderType
94 ashish 8454 
 
8455 
  def read(self, iprot):
8456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8458 
      return
8459 
    iprot.readStructBegin()
8460 
    while True:
8461 
      (fname, ftype, fid) = iprot.readFieldBegin()
8462 
      if ftype == TType.STOP:
8463 
        break
8464 
      if fid == 1:
8465 
        if ftype == TType.I64:
8466 
          self.transactionId = iprot.readI64();
8467 
        else:
8468 
          iprot.skip(ftype)
8469 
      elif fid == 2:
8470 
        if ftype == TType.I32:
8471 
          self.status = iprot.readI32();
8472 
        else:
8473 
          iprot.skip(ftype)
8474 
      elif fid == 3:
8475 
        if ftype == TType.STRING:
8476 
          self.description = iprot.readString();
8477 
        else:
8478 
          iprot.skip(ftype)
5387 rajveer 8479 
      elif fid == 4:
5527 anupam.sin 8480 
        if ftype == TType.I64:
8481 
          self.pickUp = iprot.readI64();
5387 rajveer 8482 
        else:
8483 
          iprot.skip(ftype)
5527 anupam.sin 8484 
      elif fid == 5:
8485 
        if ftype == TType.I32:
8486 
          self.orderType = iprot.readI32();
8487 
        else:
8488 
          iprot.skip(ftype)
94 ashish 8489 
      else:
8490 
        iprot.skip(ftype)
8491 
      iprot.readFieldEnd()
8492 
    iprot.readStructEnd()
8493 
 
8494 
  def write(self, oprot):
8495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8497 
      return
8498 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8499 
    if self.transactionId is not None:
94 ashish 8500 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8501 
      oprot.writeI64(self.transactionId)
8502 
      oprot.writeFieldEnd()
3431 rajveer 8503 
    if self.status is not None:
94 ashish 8504 
      oprot.writeFieldBegin('status', TType.I32, 2)
8505 
      oprot.writeI32(self.status)
8506 
      oprot.writeFieldEnd()
3431 rajveer 8507 
    if self.description is not None:
94 ashish 8508 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8509 
      oprot.writeString(self.description)
8510 
      oprot.writeFieldEnd()
5527 anupam.sin 8511 
    if self.pickUp is not None:
8512 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8513 
      oprot.writeI64(self.pickUp)
5387 rajveer 8514 
      oprot.writeFieldEnd()
5527 anupam.sin 8515 
    if self.orderType is not None:
8516 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8517 
      oprot.writeI32(self.orderType)
8518 
      oprot.writeFieldEnd()
94 ashish 8519 
    oprot.writeFieldStop()
8520 
    oprot.writeStructEnd()
8521 
 
3431 rajveer 8522 
  def validate(self):
8523 
    return
8524 
 
8525 
 
94 ashish 8526 
  def __repr__(self):
8527 
    L = ['%s=%r' % (key, value)
8528 
      for key, value in self.__dict__.iteritems()]
8529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8530 
 
8531 
  def __eq__(self, other):
8532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8533 
 
8534 
  def __ne__(self, other):
8535 
    return not (self == other)
8536 
 
8537 
class changeTransactionStatus_result:
8538 
  """
8539 
  Attributes:
8540 
   - success
8541 
   - ex
8542 
  """
8543 
 
8544 
  thrift_spec = (
8545 
    (0, TType.BOOL, 'success', None, None, ), # 0
8546 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8547 
  )
8548 
 
8549 
  def __init__(self, success=None, ex=None,):
8550 
    self.success = success
8551 
    self.ex = ex
8552 
 
8553 
  def read(self, iprot):
8554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8556 
      return
8557 
    iprot.readStructBegin()
8558 
    while True:
8559 
      (fname, ftype, fid) = iprot.readFieldBegin()
8560 
      if ftype == TType.STOP:
8561 
        break
8562 
      if fid == 0:
8563 
        if ftype == TType.BOOL:
8564 
          self.success = iprot.readBool();
8565 
        else:
8566 
          iprot.skip(ftype)
8567 
      elif fid == 1:
8568 
        if ftype == TType.STRUCT:
8569 
          self.ex = TransactionServiceException()
8570 
          self.ex.read(iprot)
8571 
        else:
8572 
          iprot.skip(ftype)
8573 
      else:
8574 
        iprot.skip(ftype)
8575 
      iprot.readFieldEnd()
8576 
    iprot.readStructEnd()
8577 
 
8578 
  def write(self, oprot):
8579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8581 
      return
8582 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8583 
    if self.success is not None:
94 ashish 8584 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8585 
      oprot.writeBool(self.success)
8586 
      oprot.writeFieldEnd()
3431 rajveer 8587 
    if self.ex is not None:
94 ashish 8588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8589 
      self.ex.write(oprot)
8590 
      oprot.writeFieldEnd()
8591 
    oprot.writeFieldStop()
8592 
    oprot.writeStructEnd()
8593 
 
3431 rajveer 8594 
  def validate(self):
8595 
    return
8596 
 
8597 
 
94 ashish 8598 
  def __repr__(self):
8599 
    L = ['%s=%r' % (key, value)
8600 
      for key, value in self.__dict__.iteritems()]
8601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8602 
 
8603 
  def __eq__(self, other):
8604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8605 
 
8606 
  def __ne__(self, other):
8607 
    return not (self == other)
8608 
 
1398 varun.gupt 8609 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8610 
  """
8611 
  Attributes:
8612 
   - transactionId
8613 
  """
8614 
 
8615 
  thrift_spec = (
8616 
    None, # 0
8617 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8618 
  )
8619 
 
8620 
  def __init__(self, transactionId=None,):
8621 
    self.transactionId = transactionId
8622 
 
8623 
  def read(self, iprot):
8624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8626 
      return
8627 
    iprot.readStructBegin()
8628 
    while True:
8629 
      (fname, ftype, fid) = iprot.readFieldBegin()
8630 
      if ftype == TType.STOP:
8631 
        break
8632 
      if fid == 1:
8633 
        if ftype == TType.I64:
8634 
          self.transactionId = iprot.readI64();
8635 
        else:
8636 
          iprot.skip(ftype)
8637 
      else:
8638 
        iprot.skip(ftype)
8639 
      iprot.readFieldEnd()
8640 
    iprot.readStructEnd()
8641 
 
8642 
  def write(self, oprot):
8643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8645 
      return
1398 varun.gupt 8646 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8647 
    if self.transactionId is not None:
1382 varun.gupt 8648 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8649 
      oprot.writeI64(self.transactionId)
8650 
      oprot.writeFieldEnd()
8651 
    oprot.writeFieldStop()
8652 
    oprot.writeStructEnd()
8653 
 
3431 rajveer 8654 
  def validate(self):
8655 
    return
8656 
 
8657 
 
1382 varun.gupt 8658 
  def __repr__(self):
8659 
    L = ['%s=%r' % (key, value)
8660 
      for key, value in self.__dict__.iteritems()]
8661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8662 
 
8663 
  def __eq__(self, other):
8664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8665 
 
8666 
  def __ne__(self, other):
8667 
    return not (self == other)
8668 
 
1398 varun.gupt 8669 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8670 
  """
8671 
  Attributes:
8672 
   - success
8673 
   - ex
8674 
  """
8675 
 
8676 
  thrift_spec = (
8677 
    (0, TType.BOOL, 'success', None, None, ), # 0
8678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8679 
  )
8680 
 
8681 
  def __init__(self, success=None, ex=None,):
8682 
    self.success = success
8683 
    self.ex = ex
8684 
 
8685 
  def read(self, iprot):
8686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8688 
      return
8689 
    iprot.readStructBegin()
8690 
    while True:
8691 
      (fname, ftype, fid) = iprot.readFieldBegin()
8692 
      if ftype == TType.STOP:
8693 
        break
8694 
      if fid == 0:
8695 
        if ftype == TType.BOOL:
8696 
          self.success = iprot.readBool();
8697 
        else:
8698 
          iprot.skip(ftype)
8699 
      elif fid == 1:
8700 
        if ftype == TType.STRUCT:
8701 
          self.ex = TransactionServiceException()
8702 
          self.ex.read(iprot)
8703 
        else:
8704 
          iprot.skip(ftype)
8705 
      else:
8706 
        iprot.skip(ftype)
8707 
      iprot.readFieldEnd()
8708 
    iprot.readStructEnd()
8709 
 
8710 
  def write(self, oprot):
8711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8713 
      return
1398 varun.gupt 8714 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8715 
    if self.success is not None:
1382 varun.gupt 8716 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8717 
      oprot.writeBool(self.success)
8718 
      oprot.writeFieldEnd()
3431 rajveer 8719 
    if self.ex is not None:
1382 varun.gupt 8720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8721 
      self.ex.write(oprot)
8722 
      oprot.writeFieldEnd()
8723 
    oprot.writeFieldStop()
8724 
    oprot.writeStructEnd()
8725 
 
3431 rajveer 8726 
  def validate(self):
8727 
    return
8728 
 
8729 
 
1382 varun.gupt 8730 
  def __repr__(self):
8731 
    L = ['%s=%r' % (key, value)
8732 
      for key, value in self.__dict__.iteritems()]
8733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8734 
 
8735 
  def __eq__(self, other):
8736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8737 
 
8738 
  def __ne__(self, other):
8739 
    return not (self == other)
8740 
 
483 rajveer 8741 
class getAllOrders_args:
94 ashish 8742 
  """
8743 
  Attributes:
4801 anupam.sin 8744 
   - statuses
483 rajveer 8745 
   - from_date
8746 
   - to_date
8747 
   - warehouse_id
94 ashish 8748 
  """
8749 
 
8750 
  thrift_spec = (
8751 
    None, # 0
4801 anupam.sin 8752 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8753 
    (2, TType.I64, 'from_date', None, None, ), # 2
8754 
    (3, TType.I64, 'to_date', None, None, ), # 3
8755 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8756 
  )
8757 
 
4801 anupam.sin 8758 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8759 
    self.statuses = statuses
483 rajveer 8760 
    self.from_date = from_date
8761 
    self.to_date = to_date
8762 
    self.warehouse_id = warehouse_id
94 ashish 8763 
 
8764 
  def read(self, iprot):
8765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8767 
      return
8768 
    iprot.readStructBegin()
8769 
    while True:
8770 
      (fname, ftype, fid) = iprot.readFieldBegin()
8771 
      if ftype == TType.STOP:
8772 
        break
8773 
      if fid == 1:
4801 anupam.sin 8774 
        if ftype == TType.LIST:
8775 
          self.statuses = []
6000 mandeep.dh 8776 
          (_etype87, _size84) = iprot.readListBegin()
8777 
          for _i88 in xrange(_size84):
8778 
            _elem89 = iprot.readI32();
8779 
            self.statuses.append(_elem89)
4801 anupam.sin 8780 
          iprot.readListEnd()
94 ashish 8781 
        else:
8782 
          iprot.skip(ftype)
483 rajveer 8783 
      elif fid == 2:
8784 
        if ftype == TType.I64:
8785 
          self.from_date = iprot.readI64();
94 ashish 8786 
        else:
8787 
          iprot.skip(ftype)
483 rajveer 8788 
      elif fid == 3:
8789 
        if ftype == TType.I64:
8790 
          self.to_date = iprot.readI64();
94 ashish 8791 
        else:
8792 
          iprot.skip(ftype)
483 rajveer 8793 
      elif fid == 4:
94 ashish 8794 
        if ftype == TType.I64:
483 rajveer 8795 
          self.warehouse_id = iprot.readI64();
94 ashish 8796 
        else:
8797 
          iprot.skip(ftype)
8798 
      else:
8799 
        iprot.skip(ftype)
8800 
      iprot.readFieldEnd()
8801 
    iprot.readStructEnd()
8802 
 
8803 
  def write(self, oprot):
8804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8806 
      return
483 rajveer 8807 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8808 
    if self.statuses is not None:
8809 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8810 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 8811 
      for iter90 in self.statuses:
8812 
        oprot.writeI32(iter90)
4801 anupam.sin 8813 
      oprot.writeListEnd()
94 ashish 8814 
      oprot.writeFieldEnd()
3431 rajveer 8815 
    if self.from_date is not None:
483 rajveer 8816 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8817 
      oprot.writeI64(self.from_date)
94 ashish 8818 
      oprot.writeFieldEnd()
3431 rajveer 8819 
    if self.to_date is not None:
483 rajveer 8820 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8821 
      oprot.writeI64(self.to_date)
94 ashish 8822 
      oprot.writeFieldEnd()
3431 rajveer 8823 
    if self.warehouse_id is not None:
483 rajveer 8824 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8825 
      oprot.writeI64(self.warehouse_id)
94 ashish 8826 
      oprot.writeFieldEnd()
8827 
    oprot.writeFieldStop()
8828 
    oprot.writeStructEnd()
8829 
 
3431 rajveer 8830 
  def validate(self):
8831 
    return
8832 
 
8833 
 
94 ashish 8834 
  def __repr__(self):
8835 
    L = ['%s=%r' % (key, value)
8836 
      for key, value in self.__dict__.iteritems()]
8837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8838 
 
8839 
  def __eq__(self, other):
8840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8841 
 
8842 
  def __ne__(self, other):
8843 
    return not (self == other)
8844 
 
483 rajveer 8845 
class getAllOrders_result:
94 ashish 8846 
  """
8847 
  Attributes:
8848 
   - success
8849 
   - ex
8850 
  """
8851 
 
8852 
  thrift_spec = (
483 rajveer 8853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8855 
  )
8856 
 
8857 
  def __init__(self, success=None, ex=None,):
8858 
    self.success = success
8859 
    self.ex = ex
8860 
 
8861 
  def read(self, iprot):
8862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8864 
      return
8865 
    iprot.readStructBegin()
8866 
    while True:
8867 
      (fname, ftype, fid) = iprot.readFieldBegin()
8868 
      if ftype == TType.STOP:
8869 
        break
8870 
      if fid == 0:
483 rajveer 8871 
        if ftype == TType.LIST:
8872 
          self.success = []
6000 mandeep.dh 8873 
          (_etype94, _size91) = iprot.readListBegin()
8874 
          for _i95 in xrange(_size91):
8875 
            _elem96 = Order()
8876 
            _elem96.read(iprot)
8877 
            self.success.append(_elem96)
483 rajveer 8878 
          iprot.readListEnd()
94 ashish 8879 
        else:
8880 
          iprot.skip(ftype)
8881 
      elif fid == 1:
8882 
        if ftype == TType.STRUCT:
8883 
          self.ex = TransactionServiceException()
8884 
          self.ex.read(iprot)
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      else:
8888 
        iprot.skip(ftype)
8889 
      iprot.readFieldEnd()
8890 
    iprot.readStructEnd()
8891 
 
8892 
  def write(self, oprot):
8893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8895 
      return
483 rajveer 8896 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8897 
    if self.success is not None:
483 rajveer 8898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 8900 
      for iter97 in self.success:
8901 
        iter97.write(oprot)
483 rajveer 8902 
      oprot.writeListEnd()
94 ashish 8903 
      oprot.writeFieldEnd()
3431 rajveer 8904 
    if self.ex is not None:
94 ashish 8905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8906 
      self.ex.write(oprot)
8907 
      oprot.writeFieldEnd()
8908 
    oprot.writeFieldStop()
8909 
    oprot.writeStructEnd()
8910 
 
3431 rajveer 8911 
  def validate(self):
8912 
    return
8913 
 
8914 
 
94 ashish 8915 
  def __repr__(self):
8916 
    L = ['%s=%r' % (key, value)
8917 
      for key, value in self.__dict__.iteritems()]
8918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8919 
 
8920 
  def __eq__(self, other):
8921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8922 
 
8923 
  def __ne__(self, other):
8924 
    return not (self == other)
8925 
 
4133 chandransh 8926 
class getOrdersInBatch_args:
8927 
  """
8928 
  Attributes:
8929 
   - statuses
8930 
   - offset
8931 
   - limit
8932 
   - warehouse_id
8933 
  """
8934 
 
8935 
  thrift_spec = (
8936 
    None, # 0
8937 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8938 
    (2, TType.I64, 'offset', None, None, ), # 2
8939 
    (3, TType.I64, 'limit', None, None, ), # 3
8940 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8941 
  )
8942 
 
8943 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8944 
    self.statuses = statuses
8945 
    self.offset = offset
8946 
    self.limit = limit
8947 
    self.warehouse_id = warehouse_id
8948 
 
8949 
  def read(self, iprot):
8950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8952 
      return
8953 
    iprot.readStructBegin()
8954 
    while True:
8955 
      (fname, ftype, fid) = iprot.readFieldBegin()
8956 
      if ftype == TType.STOP:
8957 
        break
8958 
      if fid == 1:
8959 
        if ftype == TType.LIST:
8960 
          self.statuses = []
6000 mandeep.dh 8961 
          (_etype101, _size98) = iprot.readListBegin()
8962 
          for _i102 in xrange(_size98):
8963 
            _elem103 = iprot.readI32();
8964 
            self.statuses.append(_elem103)
4133 chandransh 8965 
          iprot.readListEnd()
8966 
        else:
8967 
          iprot.skip(ftype)
8968 
      elif fid == 2:
8969 
        if ftype == TType.I64:
8970 
          self.offset = iprot.readI64();
8971 
        else:
8972 
          iprot.skip(ftype)
8973 
      elif fid == 3:
8974 
        if ftype == TType.I64:
8975 
          self.limit = iprot.readI64();
8976 
        else:
8977 
          iprot.skip(ftype)
8978 
      elif fid == 4:
8979 
        if ftype == TType.I64:
8980 
          self.warehouse_id = iprot.readI64();
8981 
        else:
8982 
          iprot.skip(ftype)
8983 
      else:
8984 
        iprot.skip(ftype)
8985 
      iprot.readFieldEnd()
8986 
    iprot.readStructEnd()
8987 
 
8988 
  def write(self, oprot):
8989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8991 
      return
8992 
    oprot.writeStructBegin('getOrdersInBatch_args')
8993 
    if self.statuses is not None:
8994 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8995 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 8996 
      for iter104 in self.statuses:
8997 
        oprot.writeI32(iter104)
4133 chandransh 8998 
      oprot.writeListEnd()
8999 
      oprot.writeFieldEnd()
9000 
    if self.offset is not None:
9001 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9002 
      oprot.writeI64(self.offset)
9003 
      oprot.writeFieldEnd()
9004 
    if self.limit is not None:
9005 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9006 
      oprot.writeI64(self.limit)
9007 
      oprot.writeFieldEnd()
9008 
    if self.warehouse_id is not None:
9009 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9010 
      oprot.writeI64(self.warehouse_id)
9011 
      oprot.writeFieldEnd()
9012 
    oprot.writeFieldStop()
9013 
    oprot.writeStructEnd()
9014 
 
9015 
  def validate(self):
9016 
    return
9017 
 
9018 
 
9019 
  def __repr__(self):
9020 
    L = ['%s=%r' % (key, value)
9021 
      for key, value in self.__dict__.iteritems()]
9022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9023 
 
9024 
  def __eq__(self, other):
9025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9026 
 
9027 
  def __ne__(self, other):
9028 
    return not (self == other)
9029 
 
9030 
class getOrdersInBatch_result:
9031 
  """
9032 
  Attributes:
9033 
   - success
9034 
   - ex
9035 
  """
9036 
 
9037 
  thrift_spec = (
9038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9040 
  )
9041 
 
9042 
  def __init__(self, success=None, ex=None,):
9043 
    self.success = success
9044 
    self.ex = ex
9045 
 
9046 
  def read(self, iprot):
9047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9049 
      return
9050 
    iprot.readStructBegin()
9051 
    while True:
9052 
      (fname, ftype, fid) = iprot.readFieldBegin()
9053 
      if ftype == TType.STOP:
9054 
        break
9055 
      if fid == 0:
9056 
        if ftype == TType.LIST:
9057 
          self.success = []
6000 mandeep.dh 9058 
          (_etype108, _size105) = iprot.readListBegin()
9059 
          for _i109 in xrange(_size105):
9060 
            _elem110 = Order()
9061 
            _elem110.read(iprot)
9062 
            self.success.append(_elem110)
4133 chandransh 9063 
          iprot.readListEnd()
9064 
        else:
9065 
          iprot.skip(ftype)
9066 
      elif fid == 1:
9067 
        if ftype == TType.STRUCT:
9068 
          self.ex = TransactionServiceException()
9069 
          self.ex.read(iprot)
9070 
        else:
9071 
          iprot.skip(ftype)
9072 
      else:
9073 
        iprot.skip(ftype)
9074 
      iprot.readFieldEnd()
9075 
    iprot.readStructEnd()
9076 
 
9077 
  def write(self, oprot):
9078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9080 
      return
9081 
    oprot.writeStructBegin('getOrdersInBatch_result')
9082 
    if self.success is not None:
9083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9085 
      for iter111 in self.success:
9086 
        iter111.write(oprot)
4133 chandransh 9087 
      oprot.writeListEnd()
9088 
      oprot.writeFieldEnd()
9089 
    if self.ex is not None:
9090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9091 
      self.ex.write(oprot)
9092 
      oprot.writeFieldEnd()
9093 
    oprot.writeFieldStop()
9094 
    oprot.writeStructEnd()
9095 
 
9096 
  def validate(self):
9097 
    return
9098 
 
9099 
 
9100 
  def __repr__(self):
9101 
    L = ['%s=%r' % (key, value)
9102 
      for key, value in self.__dict__.iteritems()]
9103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9104 
 
9105 
  def __eq__(self, other):
9106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9107 
 
9108 
  def __ne__(self, other):
9109 
    return not (self == other)
9110 
 
9111 
class getOrderCount_args:
9112 
  """
9113 
  Attributes:
9114 
   - statuses
9115 
   - warehouseId
9116 
  """
9117 
 
9118 
  thrift_spec = (
9119 
    None, # 0
9120 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9121 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9122 
  )
9123 
 
9124 
  def __init__(self, statuses=None, warehouseId=None,):
9125 
    self.statuses = statuses
9126 
    self.warehouseId = warehouseId
9127 
 
9128 
  def read(self, iprot):
9129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9131 
      return
9132 
    iprot.readStructBegin()
9133 
    while True:
9134 
      (fname, ftype, fid) = iprot.readFieldBegin()
9135 
      if ftype == TType.STOP:
9136 
        break
9137 
      if fid == 1:
9138 
        if ftype == TType.LIST:
9139 
          self.statuses = []
6000 mandeep.dh 9140 
          (_etype115, _size112) = iprot.readListBegin()
9141 
          for _i116 in xrange(_size112):
9142 
            _elem117 = iprot.readI32();
9143 
            self.statuses.append(_elem117)
4133 chandransh 9144 
          iprot.readListEnd()
9145 
        else:
9146 
          iprot.skip(ftype)
9147 
      elif fid == 2:
9148 
        if ftype == TType.I64:
9149 
          self.warehouseId = iprot.readI64();
9150 
        else:
9151 
          iprot.skip(ftype)
9152 
      else:
9153 
        iprot.skip(ftype)
9154 
      iprot.readFieldEnd()
9155 
    iprot.readStructEnd()
9156 
 
9157 
  def write(self, oprot):
9158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9160 
      return
9161 
    oprot.writeStructBegin('getOrderCount_args')
9162 
    if self.statuses is not None:
9163 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9164 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 9165 
      for iter118 in self.statuses:
9166 
        oprot.writeI32(iter118)
4133 chandransh 9167 
      oprot.writeListEnd()
9168 
      oprot.writeFieldEnd()
9169 
    if self.warehouseId is not None:
9170 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9171 
      oprot.writeI64(self.warehouseId)
9172 
      oprot.writeFieldEnd()
9173 
    oprot.writeFieldStop()
9174 
    oprot.writeStructEnd()
9175 
 
9176 
  def validate(self):
9177 
    return
9178 
 
9179 
 
9180 
  def __repr__(self):
9181 
    L = ['%s=%r' % (key, value)
9182 
      for key, value in self.__dict__.iteritems()]
9183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9184 
 
9185 
  def __eq__(self, other):
9186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9187 
 
9188 
  def __ne__(self, other):
9189 
    return not (self == other)
9190 
 
9191 
class getOrderCount_result:
9192 
  """
9193 
  Attributes:
9194 
   - success
9195 
   - ex
9196 
  """
9197 
 
9198 
  thrift_spec = (
9199 
    (0, TType.I32, 'success', None, None, ), # 0
9200 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9201 
  )
9202 
 
9203 
  def __init__(self, success=None, ex=None,):
9204 
    self.success = success
9205 
    self.ex = ex
9206 
 
9207 
  def read(self, iprot):
9208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9210 
      return
9211 
    iprot.readStructBegin()
9212 
    while True:
9213 
      (fname, ftype, fid) = iprot.readFieldBegin()
9214 
      if ftype == TType.STOP:
9215 
        break
9216 
      if fid == 0:
9217 
        if ftype == TType.I32:
9218 
          self.success = iprot.readI32();
9219 
        else:
9220 
          iprot.skip(ftype)
9221 
      elif fid == 1:
9222 
        if ftype == TType.STRUCT:
9223 
          self.ex = TransactionServiceException()
9224 
          self.ex.read(iprot)
9225 
        else:
9226 
          iprot.skip(ftype)
9227 
      else:
9228 
        iprot.skip(ftype)
9229 
      iprot.readFieldEnd()
9230 
    iprot.readStructEnd()
9231 
 
9232 
  def write(self, oprot):
9233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9235 
      return
9236 
    oprot.writeStructBegin('getOrderCount_result')
9237 
    if self.success is not None:
9238 
      oprot.writeFieldBegin('success', TType.I32, 0)
9239 
      oprot.writeI32(self.success)
9240 
      oprot.writeFieldEnd()
9241 
    if self.ex is not None:
9242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9243 
      self.ex.write(oprot)
9244 
      oprot.writeFieldEnd()
9245 
    oprot.writeFieldStop()
9246 
    oprot.writeStructEnd()
9247 
 
9248 
  def validate(self):
9249 
    return
9250 
 
9251 
 
9252 
  def __repr__(self):
9253 
    L = ['%s=%r' % (key, value)
9254 
      for key, value in self.__dict__.iteritems()]
9255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9256 
 
9257 
  def __eq__(self, other):
9258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9259 
 
9260 
  def __ne__(self, other):
9261 
    return not (self == other)
9262 
 
999 varun.gupt 9263 
class getOrdersByBillingDate_args:
9264 
  """
9265 
  Attributes:
9266 
   - status
9267 
   - start_billing_date
9268 
   - end_billing_date
9269 
   - warehouse_id
9270 
  """
9271 
 
9272 
  thrift_spec = (
9273 
    None, # 0
9274 
    (1, TType.I32, 'status', None, None, ), # 1
9275 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9276 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9277 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9278 
  )
9279 
 
9280 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9281 
    self.status = status
9282 
    self.start_billing_date = start_billing_date
9283 
    self.end_billing_date = end_billing_date
9284 
    self.warehouse_id = warehouse_id
9285 
 
9286 
  def read(self, iprot):
9287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9289 
      return
9290 
    iprot.readStructBegin()
9291 
    while True:
9292 
      (fname, ftype, fid) = iprot.readFieldBegin()
9293 
      if ftype == TType.STOP:
9294 
        break
9295 
      if fid == 1:
9296 
        if ftype == TType.I32:
9297 
          self.status = iprot.readI32();
9298 
        else:
9299 
          iprot.skip(ftype)
9300 
      elif fid == 2:
9301 
        if ftype == TType.I64:
9302 
          self.start_billing_date = iprot.readI64();
9303 
        else:
9304 
          iprot.skip(ftype)
9305 
      elif fid == 3:
9306 
        if ftype == TType.I64:
9307 
          self.end_billing_date = iprot.readI64();
9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 4:
9311 
        if ftype == TType.I64:
9312 
          self.warehouse_id = iprot.readI64();
9313 
        else:
9314 
          iprot.skip(ftype)
9315 
      else:
9316 
        iprot.skip(ftype)
9317 
      iprot.readFieldEnd()
9318 
    iprot.readStructEnd()
9319 
 
9320 
  def write(self, oprot):
9321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9323 
      return
9324 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9325 
    if self.status is not None:
999 varun.gupt 9326 
      oprot.writeFieldBegin('status', TType.I32, 1)
9327 
      oprot.writeI32(self.status)
9328 
      oprot.writeFieldEnd()
3431 rajveer 9329 
    if self.start_billing_date is not None:
999 varun.gupt 9330 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9331 
      oprot.writeI64(self.start_billing_date)
9332 
      oprot.writeFieldEnd()
3431 rajveer 9333 
    if self.end_billing_date is not None:
999 varun.gupt 9334 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9335 
      oprot.writeI64(self.end_billing_date)
9336 
      oprot.writeFieldEnd()
3431 rajveer 9337 
    if self.warehouse_id is not None:
999 varun.gupt 9338 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9339 
      oprot.writeI64(self.warehouse_id)
9340 
      oprot.writeFieldEnd()
9341 
    oprot.writeFieldStop()
9342 
    oprot.writeStructEnd()
9343 
 
3431 rajveer 9344 
  def validate(self):
9345 
    return
9346 
 
9347 
 
999 varun.gupt 9348 
  def __repr__(self):
9349 
    L = ['%s=%r' % (key, value)
9350 
      for key, value in self.__dict__.iteritems()]
9351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9352 
 
9353 
  def __eq__(self, other):
9354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9355 
 
9356 
  def __ne__(self, other):
9357 
    return not (self == other)
9358 
 
9359 
class getOrdersByBillingDate_result:
9360 
  """
9361 
  Attributes:
9362 
   - success
9363 
   - ex
9364 
  """
9365 
 
9366 
  thrift_spec = (
9367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9369 
  )
9370 
 
9371 
  def __init__(self, success=None, ex=None,):
9372 
    self.success = success
9373 
    self.ex = ex
9374 
 
9375 
  def read(self, iprot):
9376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9378 
      return
9379 
    iprot.readStructBegin()
9380 
    while True:
9381 
      (fname, ftype, fid) = iprot.readFieldBegin()
9382 
      if ftype == TType.STOP:
9383 
        break
9384 
      if fid == 0:
9385 
        if ftype == TType.LIST:
9386 
          self.success = []
6000 mandeep.dh 9387 
          (_etype122, _size119) = iprot.readListBegin()
9388 
          for _i123 in xrange(_size119):
9389 
            _elem124 = Order()
9390 
            _elem124.read(iprot)
9391 
            self.success.append(_elem124)
999 varun.gupt 9392 
          iprot.readListEnd()
9393 
        else:
9394 
          iprot.skip(ftype)
9395 
      elif fid == 1:
9396 
        if ftype == TType.STRUCT:
9397 
          self.ex = TransactionServiceException()
9398 
          self.ex.read(iprot)
9399 
        else:
9400 
          iprot.skip(ftype)
9401 
      else:
9402 
        iprot.skip(ftype)
9403 
      iprot.readFieldEnd()
9404 
    iprot.readStructEnd()
9405 
 
9406 
  def write(self, oprot):
9407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9409 
      return
9410 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9411 
    if self.success is not None:
999 varun.gupt 9412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9414 
      for iter125 in self.success:
9415 
        iter125.write(oprot)
999 varun.gupt 9416 
      oprot.writeListEnd()
9417 
      oprot.writeFieldEnd()
3431 rajveer 9418 
    if self.ex is not None:
999 varun.gupt 9419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9420 
      self.ex.write(oprot)
9421 
      oprot.writeFieldEnd()
9422 
    oprot.writeFieldStop()
9423 
    oprot.writeStructEnd()
9424 
 
3431 rajveer 9425 
  def validate(self):
9426 
    return
9427 
 
9428 
 
999 varun.gupt 9429 
  def __repr__(self):
9430 
    L = ['%s=%r' % (key, value)
9431 
      for key, value in self.__dict__.iteritems()]
9432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9433 
 
9434 
  def __eq__(self, other):
9435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9436 
 
9437 
  def __ne__(self, other):
9438 
    return not (self == other)
9439 
 
3427 chandransh 9440 
class getOrdersByShippingDate_args:
9441 
  """
9442 
  Attributes:
9443 
   - fromShippingDate
9444 
   - toShippingDate
9445 
   - providerId
9446 
   - warehouseId
3451 chandransh 9447 
   - cod
3427 chandransh 9448 
  """
9449 
 
9450 
  thrift_spec = (
9451 
    None, # 0
9452 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9453 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9454 
    (3, TType.I64, 'providerId', None, None, ), # 3
9455 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9456 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9457 
  )
9458 
 
3451 chandransh 9459 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9460 
    self.fromShippingDate = fromShippingDate
9461 
    self.toShippingDate = toShippingDate
9462 
    self.providerId = providerId
9463 
    self.warehouseId = warehouseId
3451 chandransh 9464 
    self.cod = cod
3427 chandransh 9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 1:
9476 
        if ftype == TType.I64:
9477 
          self.fromShippingDate = iprot.readI64();
9478 
        else:
9479 
          iprot.skip(ftype)
9480 
      elif fid == 2:
9481 
        if ftype == TType.I64:
9482 
          self.toShippingDate = iprot.readI64();
9483 
        else:
9484 
          iprot.skip(ftype)
9485 
      elif fid == 3:
9486 
        if ftype == TType.I64:
9487 
          self.providerId = iprot.readI64();
9488 
        else:
9489 
          iprot.skip(ftype)
9490 
      elif fid == 4:
9491 
        if ftype == TType.I64:
9492 
          self.warehouseId = iprot.readI64();
9493 
        else:
9494 
          iprot.skip(ftype)
3451 chandransh 9495 
      elif fid == 5:
9496 
        if ftype == TType.BOOL:
9497 
          self.cod = iprot.readBool();
9498 
        else:
9499 
          iprot.skip(ftype)
3427 chandransh 9500 
      else:
9501 
        iprot.skip(ftype)
9502 
      iprot.readFieldEnd()
9503 
    iprot.readStructEnd()
9504 
 
9505 
  def write(self, oprot):
9506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9508 
      return
9509 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9510 
    if self.fromShippingDate is not None:
3427 chandransh 9511 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9512 
      oprot.writeI64(self.fromShippingDate)
9513 
      oprot.writeFieldEnd()
3431 rajveer 9514 
    if self.toShippingDate is not None:
3427 chandransh 9515 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9516 
      oprot.writeI64(self.toShippingDate)
9517 
      oprot.writeFieldEnd()
3431 rajveer 9518 
    if self.providerId is not None:
3427 chandransh 9519 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9520 
      oprot.writeI64(self.providerId)
9521 
      oprot.writeFieldEnd()
3431 rajveer 9522 
    if self.warehouseId is not None:
3427 chandransh 9523 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9524 
      oprot.writeI64(self.warehouseId)
9525 
      oprot.writeFieldEnd()
3451 chandransh 9526 
    if self.cod is not None:
9527 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9528 
      oprot.writeBool(self.cod)
9529 
      oprot.writeFieldEnd()
3427 chandransh 9530 
    oprot.writeFieldStop()
9531 
    oprot.writeStructEnd()
9532 
 
3431 rajveer 9533 
  def validate(self):
9534 
    return
9535 
 
9536 
 
3427 chandransh 9537 
  def __repr__(self):
9538 
    L = ['%s=%r' % (key, value)
9539 
      for key, value in self.__dict__.iteritems()]
9540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9541 
 
9542 
  def __eq__(self, other):
9543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9544 
 
9545 
  def __ne__(self, other):
9546 
    return not (self == other)
9547 
 
9548 
class getOrdersByShippingDate_result:
9549 
  """
9550 
  Attributes:
9551 
   - success
9552 
   - ex
9553 
  """
9554 
 
9555 
  thrift_spec = (
9556 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9557 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9558 
  )
9559 
 
9560 
  def __init__(self, success=None, ex=None,):
9561 
    self.success = success
9562 
    self.ex = ex
9563 
 
9564 
  def read(self, iprot):
9565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9567 
      return
9568 
    iprot.readStructBegin()
9569 
    while True:
9570 
      (fname, ftype, fid) = iprot.readFieldBegin()
9571 
      if ftype == TType.STOP:
9572 
        break
9573 
      if fid == 0:
9574 
        if ftype == TType.LIST:
9575 
          self.success = []
6000 mandeep.dh 9576 
          (_etype129, _size126) = iprot.readListBegin()
9577 
          for _i130 in xrange(_size126):
9578 
            _elem131 = Order()
9579 
            _elem131.read(iprot)
9580 
            self.success.append(_elem131)
3427 chandransh 9581 
          iprot.readListEnd()
9582 
        else:
9583 
          iprot.skip(ftype)
9584 
      elif fid == 1:
9585 
        if ftype == TType.STRUCT:
9586 
          self.ex = TransactionServiceException()
9587 
          self.ex.read(iprot)
9588 
        else:
9589 
          iprot.skip(ftype)
9590 
      else:
9591 
        iprot.skip(ftype)
9592 
      iprot.readFieldEnd()
9593 
    iprot.readStructEnd()
9594 
 
9595 
  def write(self, oprot):
9596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9598 
      return
9599 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9600 
    if self.success is not None:
3427 chandransh 9601 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9602 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9603 
      for iter132 in self.success:
9604 
        iter132.write(oprot)
3427 chandransh 9605 
      oprot.writeListEnd()
9606 
      oprot.writeFieldEnd()
3431 rajveer 9607 
    if self.ex is not None:
3427 chandransh 9608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9609 
      self.ex.write(oprot)
9610 
      oprot.writeFieldEnd()
9611 
    oprot.writeFieldStop()
9612 
    oprot.writeStructEnd()
9613 
 
3431 rajveer 9614 
  def validate(self):
9615 
    return
9616 
 
9617 
 
3427 chandransh 9618 
  def __repr__(self):
9619 
    L = ['%s=%r' % (key, value)
9620 
      for key, value in self.__dict__.iteritems()]
9621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9622 
 
9623 
  def __eq__(self, other):
9624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9625 
 
9626 
  def __ne__(self, other):
9627 
    return not (self == other)
9628 
 
1382 varun.gupt 9629 
class getReturnableOrdersForCustomer_args:
9630 
  """
9631 
  Attributes:
9632 
   - customer_id
9633 
   - limit
9634 
  """
9635 
 
9636 
  thrift_spec = (
9637 
    None, # 0
9638 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9639 
    (2, TType.I64, 'limit', None, None, ), # 2
9640 
  )
9641 
 
9642 
  def __init__(self, customer_id=None, limit=None,):
9643 
    self.customer_id = customer_id
9644 
    self.limit = limit
9645 
 
9646 
  def read(self, iprot):
9647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9649 
      return
9650 
    iprot.readStructBegin()
9651 
    while True:
9652 
      (fname, ftype, fid) = iprot.readFieldBegin()
9653 
      if ftype == TType.STOP:
9654 
        break
9655 
      if fid == 1:
9656 
        if ftype == TType.I64:
9657 
          self.customer_id = iprot.readI64();
9658 
        else:
9659 
          iprot.skip(ftype)
9660 
      elif fid == 2:
9661 
        if ftype == TType.I64:
9662 
          self.limit = iprot.readI64();
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      else:
9666 
        iprot.skip(ftype)
9667 
      iprot.readFieldEnd()
9668 
    iprot.readStructEnd()
9669 
 
9670 
  def write(self, oprot):
9671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9673 
      return
9674 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9675 
    if self.customer_id is not None:
1382 varun.gupt 9676 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9677 
      oprot.writeI64(self.customer_id)
9678 
      oprot.writeFieldEnd()
3431 rajveer 9679 
    if self.limit is not None:
1382 varun.gupt 9680 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9681 
      oprot.writeI64(self.limit)
9682 
      oprot.writeFieldEnd()
9683 
    oprot.writeFieldStop()
9684 
    oprot.writeStructEnd()
9685 
 
3431 rajveer 9686 
  def validate(self):
9687 
    return
9688 
 
9689 
 
1382 varun.gupt 9690 
  def __repr__(self):
9691 
    L = ['%s=%r' % (key, value)
9692 
      for key, value in self.__dict__.iteritems()]
9693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9694 
 
9695 
  def __eq__(self, other):
9696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9697 
 
9698 
  def __ne__(self, other):
9699 
    return not (self == other)
9700 
 
9701 
class getReturnableOrdersForCustomer_result:
9702 
  """
9703 
  Attributes:
9704 
   - success
9705 
   - ex
9706 
  """
9707 
 
9708 
  thrift_spec = (
9709 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9711 
  )
9712 
 
9713 
  def __init__(self, success=None, ex=None,):
9714 
    self.success = success
9715 
    self.ex = ex
9716 
 
9717 
  def read(self, iprot):
9718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9720 
      return
9721 
    iprot.readStructBegin()
9722 
    while True:
9723 
      (fname, ftype, fid) = iprot.readFieldBegin()
9724 
      if ftype == TType.STOP:
9725 
        break
9726 
      if fid == 0:
9727 
        if ftype == TType.LIST:
9728 
          self.success = []
6000 mandeep.dh 9729 
          (_etype136, _size133) = iprot.readListBegin()
9730 
          for _i137 in xrange(_size133):
9731 
            _elem138 = iprot.readI64();
9732 
            self.success.append(_elem138)
1382 varun.gupt 9733 
          iprot.readListEnd()
9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      elif fid == 1:
9737 
        if ftype == TType.STRUCT:
9738 
          self.ex = TransactionServiceException()
9739 
          self.ex.read(iprot)
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      else:
9743 
        iprot.skip(ftype)
9744 
      iprot.readFieldEnd()
9745 
    iprot.readStructEnd()
9746 
 
9747 
  def write(self, oprot):
9748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9750 
      return
9751 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9752 
    if self.success is not None:
1382 varun.gupt 9753 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9754 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 9755 
      for iter139 in self.success:
9756 
        oprot.writeI64(iter139)
1382 varun.gupt 9757 
      oprot.writeListEnd()
9758 
      oprot.writeFieldEnd()
3431 rajveer 9759 
    if self.ex is not None:
1382 varun.gupt 9760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9761 
      self.ex.write(oprot)
9762 
      oprot.writeFieldEnd()
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
3431 rajveer 9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
1382 varun.gupt 9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
9781 
class getCancellableOrdersForCustomer_args:
9782 
  """
9783 
  Attributes:
9784 
   - customer_id
9785 
   - limit
9786 
  """
9787 
 
9788 
  thrift_spec = (
9789 
    None, # 0
9790 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9791 
    (2, TType.I64, 'limit', None, None, ), # 2
9792 
  )
9793 
 
9794 
  def __init__(self, customer_id=None, limit=None,):
9795 
    self.customer_id = customer_id
9796 
    self.limit = limit
9797 
 
9798 
  def read(self, iprot):
9799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9801 
      return
9802 
    iprot.readStructBegin()
9803 
    while True:
9804 
      (fname, ftype, fid) = iprot.readFieldBegin()
9805 
      if ftype == TType.STOP:
9806 
        break
9807 
      if fid == 1:
9808 
        if ftype == TType.I64:
9809 
          self.customer_id = iprot.readI64();
9810 
        else:
9811 
          iprot.skip(ftype)
9812 
      elif fid == 2:
9813 
        if ftype == TType.I64:
9814 
          self.limit = iprot.readI64();
9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      else:
9818 
        iprot.skip(ftype)
9819 
      iprot.readFieldEnd()
9820 
    iprot.readStructEnd()
9821 
 
9822 
  def write(self, oprot):
9823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9825 
      return
9826 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9827 
    if self.customer_id is not None:
1382 varun.gupt 9828 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9829 
      oprot.writeI64(self.customer_id)
9830 
      oprot.writeFieldEnd()
3431 rajveer 9831 
    if self.limit is not None:
1382 varun.gupt 9832 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9833 
      oprot.writeI64(self.limit)
9834 
      oprot.writeFieldEnd()
9835 
    oprot.writeFieldStop()
9836 
    oprot.writeStructEnd()
9837 
 
3431 rajveer 9838 
  def validate(self):
9839 
    return
9840 
 
9841 
 
1382 varun.gupt 9842 
  def __repr__(self):
9843 
    L = ['%s=%r' % (key, value)
9844 
      for key, value in self.__dict__.iteritems()]
9845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9846 
 
9847 
  def __eq__(self, other):
9848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9849 
 
9850 
  def __ne__(self, other):
9851 
    return not (self == other)
9852 
 
9853 
class getCancellableOrdersForCustomer_result:
9854 
  """
9855 
  Attributes:
9856 
   - success
9857 
   - ex
9858 
  """
9859 
 
9860 
  thrift_spec = (
9861 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9863 
  )
9864 
 
9865 
  def __init__(self, success=None, ex=None,):
9866 
    self.success = success
9867 
    self.ex = ex
9868 
 
9869 
  def read(self, iprot):
9870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9872 
      return
9873 
    iprot.readStructBegin()
9874 
    while True:
9875 
      (fname, ftype, fid) = iprot.readFieldBegin()
9876 
      if ftype == TType.STOP:
9877 
        break
9878 
      if fid == 0:
9879 
        if ftype == TType.LIST:
9880 
          self.success = []
6000 mandeep.dh 9881 
          (_etype143, _size140) = iprot.readListBegin()
9882 
          for _i144 in xrange(_size140):
9883 
            _elem145 = iprot.readI64();
9884 
            self.success.append(_elem145)
1382 varun.gupt 9885 
          iprot.readListEnd()
9886 
        else:
9887 
          iprot.skip(ftype)
9888 
      elif fid == 1:
9889 
        if ftype == TType.STRUCT:
9890 
          self.ex = TransactionServiceException()
9891 
          self.ex.read(iprot)
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      else:
9895 
        iprot.skip(ftype)
9896 
      iprot.readFieldEnd()
9897 
    iprot.readStructEnd()
9898 
 
9899 
  def write(self, oprot):
9900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9902 
      return
9903 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9904 
    if self.success is not None:
1382 varun.gupt 9905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9906 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 9907 
      for iter146 in self.success:
9908 
        oprot.writeI64(iter146)
1382 varun.gupt 9909 
      oprot.writeListEnd()
9910 
      oprot.writeFieldEnd()
3431 rajveer 9911 
    if self.ex is not None:
1382 varun.gupt 9912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9913 
      self.ex.write(oprot)
9914 
      oprot.writeFieldEnd()
9915 
    oprot.writeFieldStop()
9916 
    oprot.writeStructEnd()
9917 
 
3431 rajveer 9918 
  def validate(self):
9919 
    return
9920 
 
9921 
 
1382 varun.gupt 9922 
  def __repr__(self):
9923 
    L = ['%s=%r' % (key, value)
9924 
      for key, value in self.__dict__.iteritems()]
9925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9926 
 
9927 
  def __eq__(self, other):
9928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9929 
 
9930 
  def __ne__(self, other):
9931 
    return not (self == other)
9932 
 
483 rajveer 9933 
class changeOrderStatus_args:
94 ashish 9934 
  """
9935 
  Attributes:
483 rajveer 9936 
   - orderId
9937 
   - status
9938 
   - description
94 ashish 9939 
  """
9940 
 
9941 
  thrift_spec = (
9942 
    None, # 0
483 rajveer 9943 
    (1, TType.I64, 'orderId', None, None, ), # 1
9944 
    (2, TType.I32, 'status', None, None, ), # 2
9945 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9946 
  )
9947 
 
483 rajveer 9948 
  def __init__(self, orderId=None, status=None, description=None,):
9949 
    self.orderId = orderId
9950 
    self.status = status
9951 
    self.description = description
94 ashish 9952 
 
9953 
  def read(self, iprot):
9954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9956 
      return
9957 
    iprot.readStructBegin()
9958 
    while True:
9959 
      (fname, ftype, fid) = iprot.readFieldBegin()
9960 
      if ftype == TType.STOP:
9961 
        break
9962 
      if fid == 1:
9963 
        if ftype == TType.I64:
483 rajveer 9964 
          self.orderId = iprot.readI64();
94 ashish 9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      elif fid == 2:
483 rajveer 9968 
        if ftype == TType.I32:
9969 
          self.status = iprot.readI32();
94 ashish 9970 
        else:
9971 
          iprot.skip(ftype)
483 rajveer 9972 
      elif fid == 3:
9973 
        if ftype == TType.STRING:
9974 
          self.description = iprot.readString();
9975 
        else:
9976 
          iprot.skip(ftype)
94 ashish 9977 
      else:
9978 
        iprot.skip(ftype)
9979 
      iprot.readFieldEnd()
9980 
    iprot.readStructEnd()
9981 
 
9982 
  def write(self, oprot):
9983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9985 
      return
483 rajveer 9986 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9987 
    if self.orderId is not None:
483 rajveer 9988 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9989 
      oprot.writeI64(self.orderId)
94 ashish 9990 
      oprot.writeFieldEnd()
3431 rajveer 9991 
    if self.status is not None:
483 rajveer 9992 
      oprot.writeFieldBegin('status', TType.I32, 2)
9993 
      oprot.writeI32(self.status)
94 ashish 9994 
      oprot.writeFieldEnd()
3431 rajveer 9995 
    if self.description is not None:
483 rajveer 9996 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9997 
      oprot.writeString(self.description)
9998 
      oprot.writeFieldEnd()
94 ashish 9999 
    oprot.writeFieldStop()
10000 
    oprot.writeStructEnd()
10001 
 
3431 rajveer 10002 
  def validate(self):
10003 
    return
10004 
 
10005 
 
94 ashish 10006 
  def __repr__(self):
10007 
    L = ['%s=%r' % (key, value)
10008 
      for key, value in self.__dict__.iteritems()]
10009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10010 
 
10011 
  def __eq__(self, other):
10012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10013 
 
10014 
  def __ne__(self, other):
10015 
    return not (self == other)
10016 
 
483 rajveer 10017 
class changeOrderStatus_result:
94 ashish 10018 
  """
10019 
  Attributes:
10020 
   - success
10021 
   - ex
10022 
  """
10023 
 
10024 
  thrift_spec = (
10025 
    (0, TType.BOOL, 'success', None, None, ), # 0
10026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10027 
  )
10028 
 
10029 
  def __init__(self, success=None, ex=None,):
10030 
    self.success = success
10031 
    self.ex = ex
10032 
 
10033 
  def read(self, iprot):
10034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10036 
      return
10037 
    iprot.readStructBegin()
10038 
    while True:
10039 
      (fname, ftype, fid) = iprot.readFieldBegin()
10040 
      if ftype == TType.STOP:
10041 
        break
10042 
      if fid == 0:
10043 
        if ftype == TType.BOOL:
10044 
          self.success = iprot.readBool();
10045 
        else:
10046 
          iprot.skip(ftype)
10047 
      elif fid == 1:
10048 
        if ftype == TType.STRUCT:
10049 
          self.ex = TransactionServiceException()
10050 
          self.ex.read(iprot)
10051 
        else:
10052 
          iprot.skip(ftype)
10053 
      else:
10054 
        iprot.skip(ftype)
10055 
      iprot.readFieldEnd()
10056 
    iprot.readStructEnd()
10057 
 
10058 
  def write(self, oprot):
10059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10061 
      return
483 rajveer 10062 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10063 
    if self.success is not None:
94 ashish 10064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10065 
      oprot.writeBool(self.success)
10066 
      oprot.writeFieldEnd()
3431 rajveer 10067 
    if self.ex is not None:
94 ashish 10068 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10069 
      self.ex.write(oprot)
10070 
      oprot.writeFieldEnd()
10071 
    oprot.writeFieldStop()
10072 
    oprot.writeStructEnd()
10073 
 
3431 rajveer 10074 
  def validate(self):
10075 
    return
10076 
 
10077 
 
94 ashish 10078 
  def __repr__(self):
10079 
    L = ['%s=%r' % (key, value)
10080 
      for key, value in self.__dict__.iteritems()]
10081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10082 
 
10083 
  def __eq__(self, other):
10084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10085 
 
10086 
  def __ne__(self, other):
10087 
    return not (self == other)
10088 
 
3064 chandransh 10089 
class getOrdersForTransaction_args:
494 rajveer 10090 
  """
10091 
  Attributes:
3064 chandransh 10092 
   - transactionId
10093 
   - customerId
494 rajveer 10094 
  """
10095 
 
10096 
  thrift_spec = (
10097 
    None, # 0
3064 chandransh 10098 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10099 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10100 
  )
10101 
 
3064 chandransh 10102 
  def __init__(self, transactionId=None, customerId=None,):
10103 
    self.transactionId = transactionId
10104 
    self.customerId = customerId
494 rajveer 10105 
 
10106 
  def read(self, iprot):
10107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10109 
      return
10110 
    iprot.readStructBegin()
10111 
    while True:
10112 
      (fname, ftype, fid) = iprot.readFieldBegin()
10113 
      if ftype == TType.STOP:
10114 
        break
10115 
      if fid == 1:
10116 
        if ftype == TType.I64:
3064 chandransh 10117 
          self.transactionId = iprot.readI64();
494 rajveer 10118 
        else:
10119 
          iprot.skip(ftype)
10120 
      elif fid == 2:
3064 chandransh 10121 
        if ftype == TType.I64:
10122 
          self.customerId = iprot.readI64();
494 rajveer 10123 
        else:
10124 
          iprot.skip(ftype)
10125 
      else:
10126 
        iprot.skip(ftype)
10127 
      iprot.readFieldEnd()
10128 
    iprot.readStructEnd()
10129 
 
10130 
  def write(self, oprot):
10131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10133 
      return
3064 chandransh 10134 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10135 
    if self.transactionId is not None:
3064 chandransh 10136 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10137 
      oprot.writeI64(self.transactionId)
494 rajveer 10138 
      oprot.writeFieldEnd()
3431 rajveer 10139 
    if self.customerId is not None:
3064 chandransh 10140 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10141 
      oprot.writeI64(self.customerId)
494 rajveer 10142 
      oprot.writeFieldEnd()
10143 
    oprot.writeFieldStop()
10144 
    oprot.writeStructEnd()
10145 
 
3431 rajveer 10146 
  def validate(self):
10147 
    return
10148 
 
10149 
 
494 rajveer 10150 
  def __repr__(self):
10151 
    L = ['%s=%r' % (key, value)
10152 
      for key, value in self.__dict__.iteritems()]
10153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10154 
 
10155 
  def __eq__(self, other):
10156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10157 
 
10158 
  def __ne__(self, other):
10159 
    return not (self == other)
10160 
 
3064 chandransh 10161 
class getOrdersForTransaction_result:
494 rajveer 10162 
  """
10163 
  Attributes:
10164 
   - success
10165 
   - ex
10166 
  """
10167 
 
10168 
  thrift_spec = (
3064 chandransh 10169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10171 
  )
10172 
 
10173 
  def __init__(self, success=None, ex=None,):
10174 
    self.success = success
10175 
    self.ex = ex
10176 
 
10177 
  def read(self, iprot):
10178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10180 
      return
10181 
    iprot.readStructBegin()
10182 
    while True:
10183 
      (fname, ftype, fid) = iprot.readFieldBegin()
10184 
      if ftype == TType.STOP:
10185 
        break
10186 
      if fid == 0:
3064 chandransh 10187 
        if ftype == TType.LIST:
10188 
          self.success = []
6000 mandeep.dh 10189 
          (_etype150, _size147) = iprot.readListBegin()
10190 
          for _i151 in xrange(_size147):
10191 
            _elem152 = Order()
10192 
            _elem152.read(iprot)
10193 
            self.success.append(_elem152)
3064 chandransh 10194 
          iprot.readListEnd()
494 rajveer 10195 
        else:
10196 
          iprot.skip(ftype)
10197 
      elif fid == 1:
10198 
        if ftype == TType.STRUCT:
10199 
          self.ex = TransactionServiceException()
10200 
          self.ex.read(iprot)
10201 
        else:
10202 
          iprot.skip(ftype)
10203 
      else:
10204 
        iprot.skip(ftype)
10205 
      iprot.readFieldEnd()
10206 
    iprot.readStructEnd()
10207 
 
10208 
  def write(self, oprot):
10209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10211 
      return
3064 chandransh 10212 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10213 
    if self.success is not None:
3064 chandransh 10214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10216 
      for iter153 in self.success:
10217 
        iter153.write(oprot)
3064 chandransh 10218 
      oprot.writeListEnd()
494 rajveer 10219 
      oprot.writeFieldEnd()
3431 rajveer 10220 
    if self.ex is not None:
494 rajveer 10221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10222 
      self.ex.write(oprot)
10223 
      oprot.writeFieldEnd()
10224 
    oprot.writeFieldStop()
10225 
    oprot.writeStructEnd()
10226 
 
3431 rajveer 10227 
  def validate(self):
10228 
    return
10229 
 
10230 
 
494 rajveer 10231 
  def __repr__(self):
10232 
    L = ['%s=%r' % (key, value)
10233 
      for key, value in self.__dict__.iteritems()]
10234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10235 
 
10236 
  def __eq__(self, other):
10237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10238 
 
10239 
  def __ne__(self, other):
10240 
    return not (self == other)
10241 
 
3064 chandransh 10242 
class getOrdersForCustomer_args:
1149 chandransh 10243 
  """
10244 
  Attributes:
3064 chandransh 10245 
   - customerId
10246 
   - from_date
10247 
   - to_date
10248 
   - statuses
1149 chandransh 10249 
  """
10250 
 
10251 
  thrift_spec = (
10252 
    None, # 0
3064 chandransh 10253 
    (1, TType.I64, 'customerId', None, None, ), # 1
10254 
    (2, TType.I64, 'from_date', None, None, ), # 2
10255 
    (3, TType.I64, 'to_date', None, None, ), # 3
10256 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10257 
  )
10258 
 
3064 chandransh 10259 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10260 
    self.customerId = customerId
10261 
    self.from_date = from_date
10262 
    self.to_date = to_date
10263 
    self.statuses = statuses
1149 chandransh 10264 
 
10265 
  def read(self, iprot):
10266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10268 
      return
10269 
    iprot.readStructBegin()
10270 
    while True:
10271 
      (fname, ftype, fid) = iprot.readFieldBegin()
10272 
      if ftype == TType.STOP:
10273 
        break
10274 
      if fid == 1:
10275 
        if ftype == TType.I64:
3064 chandransh 10276 
          self.customerId = iprot.readI64();
1149 chandransh 10277 
        else:
10278 
          iprot.skip(ftype)
10279 
      elif fid == 2:
10280 
        if ftype == TType.I64:
3064 chandransh 10281 
          self.from_date = iprot.readI64();
1149 chandransh 10282 
        else:
10283 
          iprot.skip(ftype)
2783 chandransh 10284 
      elif fid == 3:
10285 
        if ftype == TType.I64:
3064 chandransh 10286 
          self.to_date = iprot.readI64();
2783 chandransh 10287 
        else:
10288 
          iprot.skip(ftype)
10289 
      elif fid == 4:
3064 chandransh 10290 
        if ftype == TType.LIST:
10291 
          self.statuses = []
6000 mandeep.dh 10292 
          (_etype157, _size154) = iprot.readListBegin()
10293 
          for _i158 in xrange(_size154):
10294 
            _elem159 = iprot.readI32();
10295 
            self.statuses.append(_elem159)
3064 chandransh 10296 
          iprot.readListEnd()
2783 chandransh 10297 
        else:
10298 
          iprot.skip(ftype)
1149 chandransh 10299 
      else:
10300 
        iprot.skip(ftype)
10301 
      iprot.readFieldEnd()
10302 
    iprot.readStructEnd()
10303 
 
10304 
  def write(self, oprot):
10305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10307 
      return
3064 chandransh 10308 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10309 
    if self.customerId is not None:
3064 chandransh 10310 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10311 
      oprot.writeI64(self.customerId)
1149 chandransh 10312 
      oprot.writeFieldEnd()
3431 rajveer 10313 
    if self.from_date is not None:
3064 chandransh 10314 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10315 
      oprot.writeI64(self.from_date)
1149 chandransh 10316 
      oprot.writeFieldEnd()
3431 rajveer 10317 
    if self.to_date is not None:
3064 chandransh 10318 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10319 
      oprot.writeI64(self.to_date)
2783 chandransh 10320 
      oprot.writeFieldEnd()
3431 rajveer 10321 
    if self.statuses is not None:
3064 chandransh 10322 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10323 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 10324 
      for iter160 in self.statuses:
10325 
        oprot.writeI32(iter160)
3064 chandransh 10326 
      oprot.writeListEnd()
2783 chandransh 10327 
      oprot.writeFieldEnd()
1149 chandransh 10328 
    oprot.writeFieldStop()
10329 
    oprot.writeStructEnd()
10330 
 
3431 rajveer 10331 
  def validate(self):
10332 
    return
10333 
 
10334 
 
1149 chandransh 10335 
  def __repr__(self):
10336 
    L = ['%s=%r' % (key, value)
10337 
      for key, value in self.__dict__.iteritems()]
10338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10339 
 
10340 
  def __eq__(self, other):
10341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10342 
 
10343 
  def __ne__(self, other):
10344 
    return not (self == other)
10345 
 
3064 chandransh 10346 
class getOrdersForCustomer_result:
1149 chandransh 10347 
  """
10348 
  Attributes:
10349 
   - success
10350 
   - ex
10351 
  """
10352 
 
10353 
  thrift_spec = (
3064 chandransh 10354 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10356 
  )
10357 
 
10358 
  def __init__(self, success=None, ex=None,):
10359 
    self.success = success
10360 
    self.ex = ex
10361 
 
10362 
  def read(self, iprot):
10363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10365 
      return
10366 
    iprot.readStructBegin()
10367 
    while True:
10368 
      (fname, ftype, fid) = iprot.readFieldBegin()
10369 
      if ftype == TType.STOP:
10370 
        break
10371 
      if fid == 0:
3064 chandransh 10372 
        if ftype == TType.LIST:
10373 
          self.success = []
6000 mandeep.dh 10374 
          (_etype164, _size161) = iprot.readListBegin()
10375 
          for _i165 in xrange(_size161):
10376 
            _elem166 = Order()
10377 
            _elem166.read(iprot)
10378 
            self.success.append(_elem166)
3064 chandransh 10379 
          iprot.readListEnd()
1149 chandransh 10380 
        else:
10381 
          iprot.skip(ftype)
10382 
      elif fid == 1:
10383 
        if ftype == TType.STRUCT:
10384 
          self.ex = TransactionServiceException()
10385 
          self.ex.read(iprot)
10386 
        else:
10387 
          iprot.skip(ftype)
10388 
      else:
10389 
        iprot.skip(ftype)
10390 
      iprot.readFieldEnd()
10391 
    iprot.readStructEnd()
10392 
 
10393 
  def write(self, oprot):
10394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10396 
      return
3064 chandransh 10397 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10398 
    if self.success is not None:
3064 chandransh 10399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10400 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10401 
      for iter167 in self.success:
10402 
        iter167.write(oprot)
3064 chandransh 10403 
      oprot.writeListEnd()
1149 chandransh 10404 
      oprot.writeFieldEnd()
3431 rajveer 10405 
    if self.ex is not None:
1149 chandransh 10406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10407 
      self.ex.write(oprot)
10408 
      oprot.writeFieldEnd()
10409 
    oprot.writeFieldStop()
10410 
    oprot.writeStructEnd()
10411 
 
3431 rajveer 10412 
  def validate(self):
10413 
    return
10414 
 
10415 
 
1149 chandransh 10416 
  def __repr__(self):
10417 
    L = ['%s=%r' % (key, value)
10418 
      for key, value in self.__dict__.iteritems()]
10419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10420 
 
10421 
  def __eq__(self, other):
10422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10423 
 
10424 
  def __ne__(self, other):
10425 
    return not (self == other)
10426 
 
3064 chandransh 10427 
class createOrder_args:
921 rajveer 10428 
  """
10429 
  Attributes:
3064 chandransh 10430 
   - order
921 rajveer 10431 
  """
10432 
 
10433 
  thrift_spec = (
10434 
    None, # 0
3064 chandransh 10435 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10436 
  )
10437 
 
3064 chandransh 10438 
  def __init__(self, order=None,):
10439 
    self.order = order
921 rajveer 10440 
 
10441 
  def read(self, iprot):
10442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10444 
      return
10445 
    iprot.readStructBegin()
10446 
    while True:
10447 
      (fname, ftype, fid) = iprot.readFieldBegin()
10448 
      if ftype == TType.STOP:
10449 
        break
10450 
      if fid == 1:
3064 chandransh 10451 
        if ftype == TType.STRUCT:
10452 
          self.order = Order()
10453 
          self.order.read(iprot)
921 rajveer 10454 
        else:
10455 
          iprot.skip(ftype)
10456 
      else:
10457 
        iprot.skip(ftype)
10458 
      iprot.readFieldEnd()
10459 
    iprot.readStructEnd()
10460 
 
10461 
  def write(self, oprot):
10462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10464 
      return
3064 chandransh 10465 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10466 
    if self.order is not None:
3064 chandransh 10467 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10468 
      self.order.write(oprot)
921 rajveer 10469 
      oprot.writeFieldEnd()
10470 
    oprot.writeFieldStop()
10471 
    oprot.writeStructEnd()
10472 
 
3431 rajveer 10473 
  def validate(self):
10474 
    return
10475 
 
10476 
 
921 rajveer 10477 
  def __repr__(self):
10478 
    L = ['%s=%r' % (key, value)
10479 
      for key, value in self.__dict__.iteritems()]
10480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10481 
 
10482 
  def __eq__(self, other):
10483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10484 
 
10485 
  def __ne__(self, other):
10486 
    return not (self == other)
10487 
 
3064 chandransh 10488 
class createOrder_result:
921 rajveer 10489 
  """
10490 
  Attributes:
10491 
   - success
10492 
   - ex
10493 
  """
10494 
 
10495 
  thrift_spec = (
3064 chandransh 10496 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10498 
  )
10499 
 
10500 
  def __init__(self, success=None, ex=None,):
10501 
    self.success = success
10502 
    self.ex = ex
10503 
 
10504 
  def read(self, iprot):
10505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10507 
      return
10508 
    iprot.readStructBegin()
10509 
    while True:
10510 
      (fname, ftype, fid) = iprot.readFieldBegin()
10511 
      if ftype == TType.STOP:
10512 
        break
10513 
      if fid == 0:
3064 chandransh 10514 
        if ftype == TType.I64:
10515 
          self.success = iprot.readI64();
921 rajveer 10516 
        else:
10517 
          iprot.skip(ftype)
10518 
      elif fid == 1:
10519 
        if ftype == TType.STRUCT:
10520 
          self.ex = TransactionServiceException()
10521 
          self.ex.read(iprot)
10522 
        else:
10523 
          iprot.skip(ftype)
10524 
      else:
10525 
        iprot.skip(ftype)
10526 
      iprot.readFieldEnd()
10527 
    iprot.readStructEnd()
10528 
 
10529 
  def write(self, oprot):
10530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10532 
      return
3064 chandransh 10533 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10534 
    if self.success is not None:
3064 chandransh 10535 
      oprot.writeFieldBegin('success', TType.I64, 0)
10536 
      oprot.writeI64(self.success)
921 rajveer 10537 
      oprot.writeFieldEnd()
3431 rajveer 10538 
    if self.ex is not None:
921 rajveer 10539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10540 
      self.ex.write(oprot)
10541 
      oprot.writeFieldEnd()
10542 
    oprot.writeFieldStop()
10543 
    oprot.writeStructEnd()
10544 
 
3431 rajveer 10545 
  def validate(self):
10546 
    return
10547 
 
10548 
 
921 rajveer 10549 
  def __repr__(self):
10550 
    L = ['%s=%r' % (key, value)
10551 
      for key, value in self.__dict__.iteritems()]
10552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10553 
 
10554 
  def __eq__(self, other):
10555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10556 
 
10557 
  def __ne__(self, other):
10558 
    return not (self == other)
10559 
 
3064 chandransh 10560 
class getOrder_args:
921 rajveer 10561 
  """
10562 
  Attributes:
3064 chandransh 10563 
   - id
921 rajveer 10564 
  """
10565 
 
10566 
  thrift_spec = (
10567 
    None, # 0
3064 chandransh 10568 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10569 
  )
10570 
 
3064 chandransh 10571 
  def __init__(self, id=None,):
10572 
    self.id = id
921 rajveer 10573 
 
10574 
  def read(self, iprot):
10575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10577 
      return
10578 
    iprot.readStructBegin()
10579 
    while True:
10580 
      (fname, ftype, fid) = iprot.readFieldBegin()
10581 
      if ftype == TType.STOP:
10582 
        break
10583 
      if fid == 1:
10584 
        if ftype == TType.I64:
3064 chandransh 10585 
          self.id = iprot.readI64();
921 rajveer 10586 
        else:
10587 
          iprot.skip(ftype)
10588 
      else:
10589 
        iprot.skip(ftype)
10590 
      iprot.readFieldEnd()
10591 
    iprot.readStructEnd()
10592 
 
10593 
  def write(self, oprot):
10594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10596 
      return
3064 chandransh 10597 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10598 
    if self.id is not None:
3064 chandransh 10599 
      oprot.writeFieldBegin('id', TType.I64, 1)
10600 
      oprot.writeI64(self.id)
921 rajveer 10601 
      oprot.writeFieldEnd()
10602 
    oprot.writeFieldStop()
10603 
    oprot.writeStructEnd()
10604 
 
3431 rajveer 10605 
  def validate(self):
10606 
    return
10607 
 
10608 
 
921 rajveer 10609 
  def __repr__(self):
10610 
    L = ['%s=%r' % (key, value)
10611 
      for key, value in self.__dict__.iteritems()]
10612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10613 
 
10614 
  def __eq__(self, other):
10615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10616 
 
10617 
  def __ne__(self, other):
10618 
    return not (self == other)
10619 
 
3064 chandransh 10620 
class getOrder_result:
921 rajveer 10621 
  """
10622 
  Attributes:
10623 
   - success
10624 
   - ex
10625 
  """
10626 
 
10627 
  thrift_spec = (
3064 chandransh 10628 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10630 
  )
10631 
 
10632 
  def __init__(self, success=None, ex=None,):
10633 
    self.success = success
10634 
    self.ex = ex
10635 
 
10636 
  def read(self, iprot):
10637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10639 
      return
10640 
    iprot.readStructBegin()
10641 
    while True:
10642 
      (fname, ftype, fid) = iprot.readFieldBegin()
10643 
      if ftype == TType.STOP:
10644 
        break
10645 
      if fid == 0:
3064 chandransh 10646 
        if ftype == TType.STRUCT:
10647 
          self.success = Order()
10648 
          self.success.read(iprot)
921 rajveer 10649 
        else:
10650 
          iprot.skip(ftype)
10651 
      elif fid == 1:
10652 
        if ftype == TType.STRUCT:
10653 
          self.ex = TransactionServiceException()
10654 
          self.ex.read(iprot)
10655 
        else:
10656 
          iprot.skip(ftype)
10657 
      else:
10658 
        iprot.skip(ftype)
10659 
      iprot.readFieldEnd()
10660 
    iprot.readStructEnd()
10661 
 
10662 
  def write(self, oprot):
10663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10665 
      return
3064 chandransh 10666 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10667 
    if self.success is not None:
3064 chandransh 10668 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10669 
      self.success.write(oprot)
921 rajveer 10670 
      oprot.writeFieldEnd()
3431 rajveer 10671 
    if self.ex is not None:
921 rajveer 10672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10673 
      self.ex.write(oprot)
10674 
      oprot.writeFieldEnd()
10675 
    oprot.writeFieldStop()
10676 
    oprot.writeStructEnd()
10677 
 
3431 rajveer 10678 
  def validate(self):
10679 
    return
10680 
 
10681 
 
921 rajveer 10682 
  def __repr__(self):
10683 
    L = ['%s=%r' % (key, value)
10684 
      for key, value in self.__dict__.iteritems()]
10685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10686 
 
10687 
  def __eq__(self, other):
10688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10689 
 
10690 
  def __ne__(self, other):
10691 
    return not (self == other)
10692 
 
3064 chandransh 10693 
class getLineItemsForOrder_args:
94 ashish 10694 
  """
10695 
  Attributes:
3064 chandransh 10696 
   - orderId
94 ashish 10697 
  """
10698 
 
10699 
  thrift_spec = (
10700 
    None, # 0
3064 chandransh 10701 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10702 
  )
10703 
 
3064 chandransh 10704 
  def __init__(self, orderId=None,):
10705 
    self.orderId = orderId
94 ashish 10706 
 
10707 
  def read(self, iprot):
10708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10710 
      return
10711 
    iprot.readStructBegin()
10712 
    while True:
10713 
      (fname, ftype, fid) = iprot.readFieldBegin()
10714 
      if ftype == TType.STOP:
10715 
        break
10716 
      if fid == 1:
10717 
        if ftype == TType.I64:
3064 chandransh 10718 
          self.orderId = iprot.readI64();
94 ashish 10719 
        else:
10720 
          iprot.skip(ftype)
10721 
      else:
10722 
        iprot.skip(ftype)
10723 
      iprot.readFieldEnd()
10724 
    iprot.readStructEnd()
10725 
 
10726 
  def write(self, oprot):
10727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10729 
      return
3064 chandransh 10730 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10731 
    if self.orderId is not None:
3064 chandransh 10732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10733 
      oprot.writeI64(self.orderId)
94 ashish 10734 
      oprot.writeFieldEnd()
10735 
    oprot.writeFieldStop()
10736 
    oprot.writeStructEnd()
10737 
 
3431 rajveer 10738 
  def validate(self):
10739 
    return
10740 
 
10741 
 
94 ashish 10742 
  def __repr__(self):
10743 
    L = ['%s=%r' % (key, value)
10744 
      for key, value in self.__dict__.iteritems()]
10745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10746 
 
10747 
  def __eq__(self, other):
10748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10749 
 
10750 
  def __ne__(self, other):
10751 
    return not (self == other)
10752 
 
3064 chandransh 10753 
class getLineItemsForOrder_result:
94 ashish 10754 
  """
10755 
  Attributes:
10756 
   - success
10757 
   - ex
10758 
  """
10759 
 
10760 
  thrift_spec = (
3064 chandransh 10761 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10763 
  )
10764 
 
10765 
  def __init__(self, success=None, ex=None,):
10766 
    self.success = success
10767 
    self.ex = ex
10768 
 
10769 
  def read(self, iprot):
10770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10772 
      return
10773 
    iprot.readStructBegin()
10774 
    while True:
10775 
      (fname, ftype, fid) = iprot.readFieldBegin()
10776 
      if ftype == TType.STOP:
10777 
        break
10778 
      if fid == 0:
483 rajveer 10779 
        if ftype == TType.LIST:
10780 
          self.success = []
6000 mandeep.dh 10781 
          (_etype171, _size168) = iprot.readListBegin()
10782 
          for _i172 in xrange(_size168):
10783 
            _elem173 = LineItem()
10784 
            _elem173.read(iprot)
10785 
            self.success.append(_elem173)
483 rajveer 10786 
          iprot.readListEnd()
94 ashish 10787 
        else:
10788 
          iprot.skip(ftype)
10789 
      elif fid == 1:
10790 
        if ftype == TType.STRUCT:
10791 
          self.ex = TransactionServiceException()
10792 
          self.ex.read(iprot)
10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      else:
10796 
        iprot.skip(ftype)
10797 
      iprot.readFieldEnd()
10798 
    iprot.readStructEnd()
10799 
 
10800 
  def write(self, oprot):
10801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10803 
      return
3064 chandransh 10804 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10805 
    if self.success is not None:
483 rajveer 10806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10808 
      for iter174 in self.success:
10809 
        iter174.write(oprot)
483 rajveer 10810 
      oprot.writeListEnd()
94 ashish 10811 
      oprot.writeFieldEnd()
3431 rajveer 10812 
    if self.ex is not None:
94 ashish 10813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10814 
      self.ex.write(oprot)
10815 
      oprot.writeFieldEnd()
10816 
    oprot.writeFieldStop()
10817 
    oprot.writeStructEnd()
10818 
 
3431 rajveer 10819 
  def validate(self):
10820 
    return
10821 
 
10822 
 
94 ashish 10823 
  def __repr__(self):
10824 
    L = ['%s=%r' % (key, value)
10825 
      for key, value in self.__dict__.iteritems()]
10826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10827 
 
10828 
  def __eq__(self, other):
10829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10830 
 
10831 
  def __ne__(self, other):
10832 
    return not (self == other)
10833 
 
4999 phani.kuma 10834 
class getOrderList_args:
10835 
  """
10836 
  Attributes:
10837 
   - order_ids
10838 
  """
10839 
 
10840 
  thrift_spec = (
10841 
    None, # 0
10842 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10843 
  )
10844 
 
10845 
  def __init__(self, order_ids=None,):
10846 
    self.order_ids = order_ids
10847 
 
10848 
  def read(self, iprot):
10849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10851 
      return
10852 
    iprot.readStructBegin()
10853 
    while True:
10854 
      (fname, ftype, fid) = iprot.readFieldBegin()
10855 
      if ftype == TType.STOP:
10856 
        break
10857 
      if fid == 1:
10858 
        if ftype == TType.LIST:
10859 
          self.order_ids = []
6000 mandeep.dh 10860 
          (_etype178, _size175) = iprot.readListBegin()
10861 
          for _i179 in xrange(_size175):
10862 
            _elem180 = iprot.readI64();
10863 
            self.order_ids.append(_elem180)
4999 phani.kuma 10864 
          iprot.readListEnd()
10865 
        else:
10866 
          iprot.skip(ftype)
10867 
      else:
10868 
        iprot.skip(ftype)
10869 
      iprot.readFieldEnd()
10870 
    iprot.readStructEnd()
10871 
 
10872 
  def write(self, oprot):
10873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10875 
      return
10876 
    oprot.writeStructBegin('getOrderList_args')
10877 
    if self.order_ids is not None:
10878 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10879 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6000 mandeep.dh 10880 
      for iter181 in self.order_ids:
10881 
        oprot.writeI64(iter181)
4999 phani.kuma 10882 
      oprot.writeListEnd()
10883 
      oprot.writeFieldEnd()
10884 
    oprot.writeFieldStop()
10885 
    oprot.writeStructEnd()
10886 
 
10887 
  def validate(self):
10888 
    return
10889 
 
10890 
 
10891 
  def __repr__(self):
10892 
    L = ['%s=%r' % (key, value)
10893 
      for key, value in self.__dict__.iteritems()]
10894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10895 
 
10896 
  def __eq__(self, other):
10897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10898 
 
10899 
  def __ne__(self, other):
10900 
    return not (self == other)
10901 
 
10902 
class getOrderList_result:
10903 
  """
10904 
  Attributes:
10905 
   - success
10906 
  """
10907 
 
10908 
  thrift_spec = (
10909 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10910 
  )
10911 
 
10912 
  def __init__(self, success=None,):
10913 
    self.success = success
10914 
 
10915 
  def read(self, iprot):
10916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10918 
      return
10919 
    iprot.readStructBegin()
10920 
    while True:
10921 
      (fname, ftype, fid) = iprot.readFieldBegin()
10922 
      if ftype == TType.STOP:
10923 
        break
10924 
      if fid == 0:
10925 
        if ftype == TType.LIST:
10926 
          self.success = []
6000 mandeep.dh 10927 
          (_etype185, _size182) = iprot.readListBegin()
10928 
          for _i186 in xrange(_size182):
10929 
            _elem187 = Order()
10930 
            _elem187.read(iprot)
10931 
            self.success.append(_elem187)
4999 phani.kuma 10932 
          iprot.readListEnd()
10933 
        else:
10934 
          iprot.skip(ftype)
10935 
      else:
10936 
        iprot.skip(ftype)
10937 
      iprot.readFieldEnd()
10938 
    iprot.readStructEnd()
10939 
 
10940 
  def write(self, oprot):
10941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10943 
      return
10944 
    oprot.writeStructBegin('getOrderList_result')
10945 
    if self.success is not None:
10946 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10947 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10948 
      for iter188 in self.success:
10949 
        iter188.write(oprot)
4999 phani.kuma 10950 
      oprot.writeListEnd()
10951 
      oprot.writeFieldEnd()
10952 
    oprot.writeFieldStop()
10953 
    oprot.writeStructEnd()
10954 
 
10955 
  def validate(self):
10956 
    return
10957 
 
10958 
 
10959 
  def __repr__(self):
10960 
    L = ['%s=%r' % (key, value)
10961 
      for key, value in self.__dict__.iteritems()]
10962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10963 
 
10964 
  def __eq__(self, other):
10965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10966 
 
10967 
  def __ne__(self, other):
10968 
    return not (self == other)
10969 
 
5386 phani.kuma 10970 
class getOrderListForVendor_args:
10971 
  """
10972 
  Attributes:
10973 
   - order_ids
10974 
   - vendorId
10975 
  """
10976 
 
10977 
  thrift_spec = (
10978 
    None, # 0
10979 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10980 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10981 
  )
10982 
 
10983 
  def __init__(self, order_ids=None, vendorId=None,):
10984 
    self.order_ids = order_ids
10985 
    self.vendorId = vendorId
10986 
 
10987 
  def read(self, iprot):
10988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10990 
      return
10991 
    iprot.readStructBegin()
10992 
    while True:
10993 
      (fname, ftype, fid) = iprot.readFieldBegin()
10994 
      if ftype == TType.STOP:
10995 
        break
10996 
      if fid == 1:
10997 
        if ftype == TType.LIST:
10998 
          self.order_ids = []
6000 mandeep.dh 10999 
          (_etype192, _size189) = iprot.readListBegin()
11000 
          for _i193 in xrange(_size189):
11001 
            _elem194 = iprot.readI64();
11002 
            self.order_ids.append(_elem194)
5386 phani.kuma 11003 
          iprot.readListEnd()
11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      elif fid == 2:
11007 
        if ftype == TType.I64:
11008 
          self.vendorId = iprot.readI64();
11009 
        else:
11010 
          iprot.skip(ftype)
11011 
      else:
11012 
        iprot.skip(ftype)
11013 
      iprot.readFieldEnd()
11014 
    iprot.readStructEnd()
11015 
 
11016 
  def write(self, oprot):
11017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11019 
      return
11020 
    oprot.writeStructBegin('getOrderListForVendor_args')
11021 
    if self.order_ids is not None:
11022 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11023 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6000 mandeep.dh 11024 
      for iter195 in self.order_ids:
11025 
        oprot.writeI64(iter195)
5386 phani.kuma 11026 
      oprot.writeListEnd()
11027 
      oprot.writeFieldEnd()
11028 
    if self.vendorId is not None:
11029 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11030 
      oprot.writeI64(self.vendorId)
11031 
      oprot.writeFieldEnd()
11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
11050 
class getOrderListForVendor_result:
11051 
  """
11052 
  Attributes:
11053 
   - success
11054 
  """
11055 
 
11056 
  thrift_spec = (
11057 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11058 
  )
11059 
 
11060 
  def __init__(self, success=None,):
11061 
    self.success = success
11062 
 
11063 
  def read(self, iprot):
11064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11066 
      return
11067 
    iprot.readStructBegin()
11068 
    while True:
11069 
      (fname, ftype, fid) = iprot.readFieldBegin()
11070 
      if ftype == TType.STOP:
11071 
        break
11072 
      if fid == 0:
11073 
        if ftype == TType.LIST:
11074 
          self.success = []
6000 mandeep.dh 11075 
          (_etype199, _size196) = iprot.readListBegin()
11076 
          for _i200 in xrange(_size196):
11077 
            _elem201 = Order()
11078 
            _elem201.read(iprot)
11079 
            self.success.append(_elem201)
5386 phani.kuma 11080 
          iprot.readListEnd()
11081 
        else:
11082 
          iprot.skip(ftype)
11083 
      else:
11084 
        iprot.skip(ftype)
11085 
      iprot.readFieldEnd()
11086 
    iprot.readStructEnd()
11087 
 
11088 
  def write(self, oprot):
11089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11091 
      return
11092 
    oprot.writeStructBegin('getOrderListForVendor_result')
11093 
    if self.success is not None:
11094 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11095 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 11096 
      for iter202 in self.success:
11097 
        iter202.write(oprot)
5386 phani.kuma 11098 
      oprot.writeListEnd()
11099 
      oprot.writeFieldEnd()
11100 
    oprot.writeFieldStop()
11101 
    oprot.writeStructEnd()
11102 
 
11103 
  def validate(self):
11104 
    return
11105 
 
11106 
 
11107 
  def __repr__(self):
11108 
    L = ['%s=%r' % (key, value)
11109 
      for key, value in self.__dict__.iteritems()]
11110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11111 
 
11112 
  def __eq__(self, other):
11113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11114 
 
11115 
  def __ne__(self, other):
11116 
    return not (self == other)
11117 
 
3064 chandransh 11118 
class getOrderForCustomer_args:
94 ashish 11119 
  """
11120 
  Attributes:
3064 chandransh 11121 
   - orderId
483 rajveer 11122 
   - customerId
94 ashish 11123 
  """
11124 
 
11125 
  thrift_spec = (
11126 
    None, # 0
3064 chandransh 11127 
    (1, TType.I64, 'orderId', None, None, ), # 1
11128 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11129 
  )
11130 
 
3064 chandransh 11131 
  def __init__(self, orderId=None, customerId=None,):
11132 
    self.orderId = orderId
483 rajveer 11133 
    self.customerId = customerId
94 ashish 11134 
 
11135 
  def read(self, iprot):
11136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11138 
      return
11139 
    iprot.readStructBegin()
11140 
    while True:
11141 
      (fname, ftype, fid) = iprot.readFieldBegin()
11142 
      if ftype == TType.STOP:
11143 
        break
11144 
      if fid == 1:
11145 
        if ftype == TType.I64:
3064 chandransh 11146 
          self.orderId = iprot.readI64();
94 ashish 11147 
        else:
11148 
          iprot.skip(ftype)
11149 
      elif fid == 2:
11150 
        if ftype == TType.I64:
3064 chandransh 11151 
          self.customerId = iprot.readI64();
94 ashish 11152 
        else:
11153 
          iprot.skip(ftype)
11154 
      else:
11155 
        iprot.skip(ftype)
11156 
      iprot.readFieldEnd()
11157 
    iprot.readStructEnd()
11158 
 
11159 
  def write(self, oprot):
11160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11162 
      return
3064 chandransh 11163 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11164 
    if self.orderId is not None:
3064 chandransh 11165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11166 
      oprot.writeI64(self.orderId)
11167 
      oprot.writeFieldEnd()
3431 rajveer 11168 
    if self.customerId is not None:
3064 chandransh 11169 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11170 
      oprot.writeI64(self.customerId)
94 ashish 11171 
      oprot.writeFieldEnd()
11172 
    oprot.writeFieldStop()
11173 
    oprot.writeStructEnd()
11174 
 
3431 rajveer 11175 
  def validate(self):
11176 
    return
11177 
 
11178 
 
94 ashish 11179 
  def __repr__(self):
11180 
    L = ['%s=%r' % (key, value)
11181 
      for key, value in self.__dict__.iteritems()]
11182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11183 
 
11184 
  def __eq__(self, other):
11185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11186 
 
11187 
  def __ne__(self, other):
11188 
    return not (self == other)
11189 
 
3064 chandransh 11190 
class getOrderForCustomer_result:
94 ashish 11191 
  """
11192 
  Attributes:
11193 
   - success
11194 
   - ex
11195 
  """
11196 
 
11197 
  thrift_spec = (
3064 chandransh 11198 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11200 
  )
11201 
 
11202 
  def __init__(self, success=None, ex=None,):
11203 
    self.success = success
11204 
    self.ex = ex
11205 
 
11206 
  def read(self, iprot):
11207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11209 
      return
11210 
    iprot.readStructBegin()
11211 
    while True:
11212 
      (fname, ftype, fid) = iprot.readFieldBegin()
11213 
      if ftype == TType.STOP:
11214 
        break
11215 
      if fid == 0:
3064 chandransh 11216 
        if ftype == TType.STRUCT:
11217 
          self.success = Order()
11218 
          self.success.read(iprot)
94 ashish 11219 
        else:
11220 
          iprot.skip(ftype)
11221 
      elif fid == 1:
11222 
        if ftype == TType.STRUCT:
11223 
          self.ex = TransactionServiceException()
11224 
          self.ex.read(iprot)
11225 
        else:
11226 
          iprot.skip(ftype)
11227 
      else:
11228 
        iprot.skip(ftype)
11229 
      iprot.readFieldEnd()
11230 
    iprot.readStructEnd()
11231 
 
11232 
  def write(self, oprot):
11233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11235 
      return
3064 chandransh 11236 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11237 
    if self.success is not None:
3064 chandransh 11238 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11239 
      self.success.write(oprot)
94 ashish 11240 
      oprot.writeFieldEnd()
3431 rajveer 11241 
    if self.ex is not None:
94 ashish 11242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11243 
      self.ex.write(oprot)
11244 
      oprot.writeFieldEnd()
11245 
    oprot.writeFieldStop()
11246 
    oprot.writeStructEnd()
11247 
 
3431 rajveer 11248 
  def validate(self):
11249 
    return
11250 
 
11251 
 
94 ashish 11252 
  def __repr__(self):
11253 
    L = ['%s=%r' % (key, value)
11254 
      for key, value in self.__dict__.iteritems()]
11255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11256 
 
11257 
  def __eq__(self, other):
11258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11259 
 
11260 
  def __ne__(self, other):
11261 
    return not (self == other)
11262 
 
3064 chandransh 11263 
class getAlerts_args:
94 ashish 11264 
  """
11265 
  Attributes:
4394 rajveer 11266 
   - type
4444 rajveer 11267 
   - warehouseId
4394 rajveer 11268 
   - status
11269 
   - timestamp
94 ashish 11270 
  """
11271 
 
11272 
  thrift_spec = (
11273 
    None, # 0
4394 rajveer 11274 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11275 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11276 
    (3, TType.I64, 'status', None, None, ), # 3
11277 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11278 
  )
11279 
 
4444 rajveer 11280 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11281 
    self.type = type
4444 rajveer 11282 
    self.warehouseId = warehouseId
4394 rajveer 11283 
    self.status = status
11284 
    self.timestamp = timestamp
94 ashish 11285 
 
11286 
  def read(self, iprot):
11287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11289 
      return
11290 
    iprot.readStructBegin()
11291 
    while True:
11292 
      (fname, ftype, fid) = iprot.readFieldBegin()
11293 
      if ftype == TType.STOP:
11294 
        break
11295 
      if fid == 1:
3064 chandransh 11296 
        if ftype == TType.I64:
4394 rajveer 11297 
          self.type = iprot.readI64();
94 ashish 11298 
        else:
11299 
          iprot.skip(ftype)
3064 chandransh 11300 
      elif fid == 2:
4394 rajveer 11301 
        if ftype == TType.I64:
4444 rajveer 11302 
          self.warehouseId = iprot.readI64();
3064 chandransh 11303 
        else:
11304 
          iprot.skip(ftype)
4394 rajveer 11305 
      elif fid == 3:
11306 
        if ftype == TType.I64:
4444 rajveer 11307 
          self.status = iprot.readI64();
11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      elif fid == 4:
11311 
        if ftype == TType.I64:
4394 rajveer 11312 
          self.timestamp = iprot.readI64();
11313 
        else:
11314 
          iprot.skip(ftype)
94 ashish 11315 
      else:
11316 
        iprot.skip(ftype)
11317 
      iprot.readFieldEnd()
11318 
    iprot.readStructEnd()
11319 
 
11320 
  def write(self, oprot):
11321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11323 
      return
3064 chandransh 11324 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11325 
    if self.type is not None:
11326 
      oprot.writeFieldBegin('type', TType.I64, 1)
11327 
      oprot.writeI64(self.type)
94 ashish 11328 
      oprot.writeFieldEnd()
4444 rajveer 11329 
    if self.warehouseId is not None:
11330 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11331 
      oprot.writeI64(self.warehouseId)
11332 
      oprot.writeFieldEnd()
4394 rajveer 11333 
    if self.status is not None:
4444 rajveer 11334 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11335 
      oprot.writeI64(self.status)
3064 chandransh 11336 
      oprot.writeFieldEnd()
4394 rajveer 11337 
    if self.timestamp is not None:
4444 rajveer 11338 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11339 
      oprot.writeI64(self.timestamp)
11340 
      oprot.writeFieldEnd()
94 ashish 11341 
    oprot.writeFieldStop()
11342 
    oprot.writeStructEnd()
11343 
 
3431 rajveer 11344 
  def validate(self):
11345 
    return
11346 
 
11347 
 
94 ashish 11348 
  def __repr__(self):
11349 
    L = ['%s=%r' % (key, value)
11350 
      for key, value in self.__dict__.iteritems()]
11351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11352 
 
11353 
  def __eq__(self, other):
11354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11355 
 
11356 
  def __ne__(self, other):
11357 
    return not (self == other)
11358 
 
3064 chandransh 11359 
class getAlerts_result:
94 ashish 11360 
  """
11361 
  Attributes:
11362 
   - success
11363 
  """
11364 
 
11365 
  thrift_spec = (
3064 chandransh 11366 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11367 
  )
11368 
 
3064 chandransh 11369 
  def __init__(self, success=None,):
94 ashish 11370 
    self.success = success
11371 
 
11372 
  def read(self, iprot):
11373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11375 
      return
11376 
    iprot.readStructBegin()
11377 
    while True:
11378 
      (fname, ftype, fid) = iprot.readFieldBegin()
11379 
      if ftype == TType.STOP:
11380 
        break
11381 
      if fid == 0:
3064 chandransh 11382 
        if ftype == TType.LIST:
11383 
          self.success = []
6000 mandeep.dh 11384 
          (_etype206, _size203) = iprot.readListBegin()
11385 
          for _i207 in xrange(_size203):
11386 
            _elem208 = Alert()
11387 
            _elem208.read(iprot)
11388 
            self.success.append(_elem208)
3064 chandransh 11389 
          iprot.readListEnd()
94 ashish 11390 
        else:
11391 
          iprot.skip(ftype)
11392 
      else:
11393 
        iprot.skip(ftype)
11394 
      iprot.readFieldEnd()
11395 
    iprot.readStructEnd()
11396 
 
11397 
  def write(self, oprot):
11398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11400 
      return
3064 chandransh 11401 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11402 
    if self.success is not None:
3064 chandransh 11403 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11404 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 11405 
      for iter209 in self.success:
11406 
        iter209.write(oprot)
3064 chandransh 11407 
      oprot.writeListEnd()
94 ashish 11408 
      oprot.writeFieldEnd()
11409 
    oprot.writeFieldStop()
11410 
    oprot.writeStructEnd()
11411 
 
3431 rajveer 11412 
  def validate(self):
11413 
    return
11414 
 
11415 
 
94 ashish 11416 
  def __repr__(self):
11417 
    L = ['%s=%r' % (key, value)
11418 
      for key, value in self.__dict__.iteritems()]
11419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11420 
 
11421 
  def __eq__(self, other):
11422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11423 
 
11424 
  def __ne__(self, other):
11425 
    return not (self == other)
11426 
 
4394 rajveer 11427 
class addAlert_args:
94 ashish 11428 
  """
11429 
  Attributes:
3064 chandransh 11430 
   - type
4444 rajveer 11431 
   - warehouseId
4394 rajveer 11432 
   - description
94 ashish 11433 
  """
11434 
 
11435 
  thrift_spec = (
11436 
    None, # 0
4394 rajveer 11437 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11438 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11439 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11440 
  )
11441 
 
4444 rajveer 11442 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11443 
    self.type = type
4444 rajveer 11444 
    self.warehouseId = warehouseId
4394 rajveer 11445 
    self.description = description
94 ashish 11446 
 
11447 
  def read(self, iprot):
11448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11450 
      return
11451 
    iprot.readStructBegin()
11452 
    while True:
11453 
      (fname, ftype, fid) = iprot.readFieldBegin()
11454 
      if ftype == TType.STOP:
11455 
        break
11456 
      if fid == 1:
11457 
        if ftype == TType.I64:
4394 rajveer 11458 
          self.type = iprot.readI64();
94 ashish 11459 
        else:
11460 
          iprot.skip(ftype)
3064 chandransh 11461 
      elif fid == 2:
4444 rajveer 11462 
        if ftype == TType.I64:
11463 
          self.warehouseId = iprot.readI64();
11464 
        else:
11465 
          iprot.skip(ftype)
11466 
      elif fid == 3:
3064 chandransh 11467 
        if ftype == TType.STRING:
4394 rajveer 11468 
          self.description = iprot.readString();
3064 chandransh 11469 
        else:
11470 
          iprot.skip(ftype)
94 ashish 11471 
      else:
11472 
        iprot.skip(ftype)
11473 
      iprot.readFieldEnd()
11474 
    iprot.readStructEnd()
11475 
 
11476 
  def write(self, oprot):
11477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11479 
      return
4394 rajveer 11480 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11481 
    if self.type is not None:
4394 rajveer 11482 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11483 
      oprot.writeI64(self.type)
11484 
      oprot.writeFieldEnd()
4444 rajveer 11485 
    if self.warehouseId is not None:
11486 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11487 
      oprot.writeI64(self.warehouseId)
11488 
      oprot.writeFieldEnd()
4394 rajveer 11489 
    if self.description is not None:
4444 rajveer 11490 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11491 
      oprot.writeString(self.description)
3064 chandransh 11492 
      oprot.writeFieldEnd()
94 ashish 11493 
    oprot.writeFieldStop()
11494 
    oprot.writeStructEnd()
11495 
 
3431 rajveer 11496 
  def validate(self):
11497 
    return
11498 
 
11499 
 
94 ashish 11500 
  def __repr__(self):
11501 
    L = ['%s=%r' % (key, value)
11502 
      for key, value in self.__dict__.iteritems()]
11503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11504 
 
11505 
  def __eq__(self, other):
11506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11507 
 
11508 
  def __ne__(self, other):
11509 
    return not (self == other)
11510 
 
4394 rajveer 11511 
class addAlert_result:
3064 chandransh 11512 
 
11513 
  thrift_spec = (
11514 
  )
11515 
 
11516 
  def read(self, iprot):
11517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11519 
      return
11520 
    iprot.readStructBegin()
11521 
    while True:
11522 
      (fname, ftype, fid) = iprot.readFieldBegin()
11523 
      if ftype == TType.STOP:
11524 
        break
11525 
      else:
11526 
        iprot.skip(ftype)
11527 
      iprot.readFieldEnd()
11528 
    iprot.readStructEnd()
11529 
 
11530 
  def write(self, oprot):
11531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11533 
      return
4394 rajveer 11534 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11535 
    oprot.writeFieldStop()
11536 
    oprot.writeStructEnd()
11537 
 
3431 rajveer 11538 
  def validate(self):
11539 
    return
11540 
 
11541 
 
3064 chandransh 11542 
  def __repr__(self):
11543 
    L = ['%s=%r' % (key, value)
11544 
      for key, value in self.__dict__.iteritems()]
11545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11546 
 
11547 
  def __eq__(self, other):
11548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11549 
 
11550 
  def __ne__(self, other):
11551 
    return not (self == other)
11552 
 
4444 rajveer 11553 
class markAlertsAsSeen_args:
11554 
  """
11555 
  Attributes:
11556 
   - warehouseId
11557 
  """
11558 
 
11559 
  thrift_spec = (
11560 
    None, # 0
11561 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11562 
  )
11563 
 
11564 
  def __init__(self, warehouseId=None,):
11565 
    self.warehouseId = warehouseId
11566 
 
11567 
  def read(self, iprot):
11568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11570 
      return
11571 
    iprot.readStructBegin()
11572 
    while True:
11573 
      (fname, ftype, fid) = iprot.readFieldBegin()
11574 
      if ftype == TType.STOP:
11575 
        break
11576 
      if fid == 1:
11577 
        if ftype == TType.I64:
11578 
          self.warehouseId = iprot.readI64();
11579 
        else:
11580 
          iprot.skip(ftype)
11581 
      else:
11582 
        iprot.skip(ftype)
11583 
      iprot.readFieldEnd()
11584 
    iprot.readStructEnd()
11585 
 
11586 
  def write(self, oprot):
11587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11589 
      return
11590 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11591 
    if self.warehouseId is not None:
11592 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11593 
      oprot.writeI64(self.warehouseId)
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
11613 
class markAlertsAsSeen_result:
11614 
 
11615 
  thrift_spec = (
11616 
  )
11617 
 
11618 
  def read(self, iprot):
11619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11621 
      return
11622 
    iprot.readStructBegin()
11623 
    while True:
11624 
      (fname, ftype, fid) = iprot.readFieldBegin()
11625 
      if ftype == TType.STOP:
11626 
        break
11627 
      else:
11628 
        iprot.skip(ftype)
11629 
      iprot.readFieldEnd()
11630 
    iprot.readStructEnd()
11631 
 
11632 
  def write(self, oprot):
11633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11635 
      return
11636 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11637 
    oprot.writeFieldStop()
11638 
    oprot.writeStructEnd()
11639 
 
11640 
  def validate(self):
11641 
    return
11642 
 
11643 
 
11644 
  def __repr__(self):
11645 
    L = ['%s=%r' % (key, value)
11646 
      for key, value in self.__dict__.iteritems()]
11647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11648 
 
11649 
  def __eq__(self, other):
11650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11651 
 
11652 
  def __ne__(self, other):
11653 
    return not (self == other)
11654 
 
3064 chandransh 11655 
class getValidOrderCount_args:
11656 
 
11657 
  thrift_spec = (
11658 
  )
11659 
 
11660 
  def read(self, iprot):
11661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11663 
      return
11664 
    iprot.readStructBegin()
11665 
    while True:
11666 
      (fname, ftype, fid) = iprot.readFieldBegin()
11667 
      if ftype == TType.STOP:
11668 
        break
11669 
      else:
11670 
        iprot.skip(ftype)
11671 
      iprot.readFieldEnd()
11672 
    iprot.readStructEnd()
11673 
 
11674 
  def write(self, oprot):
11675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11677 
      return
11678 
    oprot.writeStructBegin('getValidOrderCount_args')
11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
3431 rajveer 11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
3064 chandransh 11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
11697 
class getValidOrderCount_result:
94 ashish 11698 
  """
11699 
  Attributes:
11700 
   - success
11701 
  """
11702 
 
11703 
  thrift_spec = (
3064 chandransh 11704 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11705 
  )
11706 
 
3064 chandransh 11707 
  def __init__(self, success=None,):
94 ashish 11708 
    self.success = success
11709 
 
11710 
  def read(self, iprot):
11711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11713 
      return
11714 
    iprot.readStructBegin()
11715 
    while True:
11716 
      (fname, ftype, fid) = iprot.readFieldBegin()
11717 
      if ftype == TType.STOP:
11718 
        break
11719 
      if fid == 0:
3064 chandransh 11720 
        if ftype == TType.I64:
11721 
          self.success = iprot.readI64();
94 ashish 11722 
        else:
11723 
          iprot.skip(ftype)
11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
3064 chandransh 11733 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11734 
    if self.success is not None:
3064 chandransh 11735 
      oprot.writeFieldBegin('success', TType.I64, 0)
11736 
      oprot.writeI64(self.success)
94 ashish 11737 
      oprot.writeFieldEnd()
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
3431 rajveer 11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
94 ashish 11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
3064 chandransh 11756 
class getNoOfCustomersWithSuccessfulTransaction_args:
11757 
 
11758 
  thrift_spec = (
11759 
  )
11760 
 
11761 
  def read(self, iprot):
11762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11764 
      return
11765 
    iprot.readStructBegin()
11766 
    while True:
11767 
      (fname, ftype, fid) = iprot.readFieldBegin()
11768 
      if ftype == TType.STOP:
11769 
        break
11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
11779 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11780 
    oprot.writeFieldStop()
11781 
    oprot.writeStructEnd()
11782 
 
3431 rajveer 11783 
  def validate(self):
11784 
    return
11785 
 
11786 
 
3064 chandransh 11787 
  def __repr__(self):
11788 
    L = ['%s=%r' % (key, value)
11789 
      for key, value in self.__dict__.iteritems()]
11790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11791 
 
11792 
  def __eq__(self, other):
11793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11794 
 
11795 
  def __ne__(self, other):
11796 
    return not (self == other)
11797 
 
11798 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11799 
  """
11800 
  Attributes:
3064 chandransh 11801 
   - success
94 ashish 11802 
  """
11803 
 
11804 
  thrift_spec = (
3064 chandransh 11805 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11806 
  )
11807 
 
3064 chandransh 11808 
  def __init__(self, success=None,):
11809 
    self.success = success
94 ashish 11810 
 
11811 
  def read(self, iprot):
11812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11814 
      return
11815 
    iprot.readStructBegin()
11816 
    while True:
11817 
      (fname, ftype, fid) = iprot.readFieldBegin()
11818 
      if ftype == TType.STOP:
11819 
        break
3064 chandransh 11820 
      if fid == 0:
94 ashish 11821 
        if ftype == TType.I64:
3064 chandransh 11822 
          self.success = iprot.readI64();
94 ashish 11823 
        else:
11824 
          iprot.skip(ftype)
11825 
      else:
11826 
        iprot.skip(ftype)
11827 
      iprot.readFieldEnd()
11828 
    iprot.readStructEnd()
11829 
 
11830 
  def write(self, oprot):
11831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11833 
      return
3064 chandransh 11834 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11835 
    if self.success is not None:
3064 chandransh 11836 
      oprot.writeFieldBegin('success', TType.I64, 0)
11837 
      oprot.writeI64(self.success)
94 ashish 11838 
      oprot.writeFieldEnd()
11839 
    oprot.writeFieldStop()
11840 
    oprot.writeStructEnd()
11841 
 
3431 rajveer 11842 
  def validate(self):
11843 
    return
11844 
 
11845 
 
94 ashish 11846 
  def __repr__(self):
11847 
    L = ['%s=%r' % (key, value)
11848 
      for key, value in self.__dict__.iteritems()]
11849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11850 
 
11851 
  def __eq__(self, other):
11852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11853 
 
11854 
  def __ne__(self, other):
11855 
    return not (self == other)
11856 
 
3064 chandransh 11857 
class getValidOrdersAmountRange_args:
11858 
 
11859 
  thrift_spec = (
11860 
  )
11861 
 
11862 
  def read(self, iprot):
11863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11865 
      return
11866 
    iprot.readStructBegin()
11867 
    while True:
11868 
      (fname, ftype, fid) = iprot.readFieldBegin()
11869 
      if ftype == TType.STOP:
11870 
        break
11871 
      else:
11872 
        iprot.skip(ftype)
11873 
      iprot.readFieldEnd()
11874 
    iprot.readStructEnd()
11875 
 
11876 
  def write(self, oprot):
11877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11879 
      return
11880 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
3431 rajveer 11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
3064 chandransh 11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
11899 
class getValidOrdersAmountRange_result:
94 ashish 11900 
  """
11901 
  Attributes:
11902 
   - success
11903 
  """
11904 
 
11905 
  thrift_spec = (
3064 chandransh 11906 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11907 
  )
11908 
 
3064 chandransh 11909 
  def __init__(self, success=None,):
94 ashish 11910 
    self.success = success
11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
11921 
      if fid == 0:
483 rajveer 11922 
        if ftype == TType.LIST:
11923 
          self.success = []
6000 mandeep.dh 11924 
          (_etype213, _size210) = iprot.readListBegin()
11925 
          for _i214 in xrange(_size210):
11926 
            _elem215 = iprot.readDouble();
11927 
            self.success.append(_elem215)
483 rajveer 11928 
          iprot.readListEnd()
94 ashish 11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      else:
11932 
        iprot.skip(ftype)
11933 
      iprot.readFieldEnd()
11934 
    iprot.readStructEnd()
11935 
 
11936 
  def write(self, oprot):
11937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11939 
      return
3064 chandransh 11940 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11941 
    if self.success is not None:
483 rajveer 11942 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11943 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6000 mandeep.dh 11944 
      for iter216 in self.success:
11945 
        oprot.writeDouble(iter216)
483 rajveer 11946 
      oprot.writeListEnd()
94 ashish 11947 
      oprot.writeFieldEnd()
11948 
    oprot.writeFieldStop()
11949 
    oprot.writeStructEnd()
11950 
 
3431 rajveer 11951 
  def validate(self):
11952 
    return
11953 
 
11954 
 
94 ashish 11955 
  def __repr__(self):
11956 
    L = ['%s=%r' % (key, value)
11957 
      for key, value in self.__dict__.iteritems()]
11958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11959 
 
11960 
  def __eq__(self, other):
11961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11962 
 
11963 
  def __ne__(self, other):
11964 
    return not (self == other)
11965 
 
3064 chandransh 11966 
class getValidOrders_args:
1528 ankur.sing 11967 
  """
11968 
  Attributes:
3064 chandransh 11969 
   - limit
5874 rajveer 11970 
   - onlyStore
1528 ankur.sing 11971 
  """
11972 
 
11973 
  thrift_spec = (
11974 
    None, # 0
3064 chandransh 11975 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 11976 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 11977 
  )
11978 
 
5874 rajveer 11979 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 11980 
    self.limit = limit
5874 rajveer 11981 
    self.onlyStore = onlyStore
1528 ankur.sing 11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      if fid == 1:
11993 
        if ftype == TType.I64:
3064 chandransh 11994 
          self.limit = iprot.readI64();
1528 ankur.sing 11995 
        else:
11996 
          iprot.skip(ftype)
5874 rajveer 11997 
      elif fid == 2:
11998 
        if ftype == TType.BOOL:
11999 
          self.onlyStore = iprot.readBool();
12000 
        else:
12001 
          iprot.skip(ftype)
1528 ankur.sing 12002 
      else:
12003 
        iprot.skip(ftype)
12004 
      iprot.readFieldEnd()
12005 
    iprot.readStructEnd()
12006 
 
12007 
  def write(self, oprot):
12008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12010 
      return
3064 chandransh 12011 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12012 
    if self.limit is not None:
3064 chandransh 12013 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12014 
      oprot.writeI64(self.limit)
1528 ankur.sing 12015 
      oprot.writeFieldEnd()
5874 rajveer 12016 
    if self.onlyStore is not None:
12017 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12018 
      oprot.writeBool(self.onlyStore)
12019 
      oprot.writeFieldEnd()
1528 ankur.sing 12020 
    oprot.writeFieldStop()
12021 
    oprot.writeStructEnd()
12022 
 
3431 rajveer 12023 
  def validate(self):
12024 
    return
12025 
 
12026 
 
1528 ankur.sing 12027 
  def __repr__(self):
12028 
    L = ['%s=%r' % (key, value)
12029 
      for key, value in self.__dict__.iteritems()]
12030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12031 
 
12032 
  def __eq__(self, other):
12033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12034 
 
12035 
  def __ne__(self, other):
12036 
    return not (self == other)
12037 
 
3064 chandransh 12038 
class getValidOrders_result:
1528 ankur.sing 12039 
  """
12040 
  Attributes:
12041 
   - success
12042 
  """
12043 
 
12044 
  thrift_spec = (
3064 chandransh 12045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12046 
  )
12047 
 
3064 chandransh 12048 
  def __init__(self, success=None,):
1528 ankur.sing 12049 
    self.success = success
12050 
 
12051 
  def read(self, iprot):
12052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12054 
      return
12055 
    iprot.readStructBegin()
12056 
    while True:
12057 
      (fname, ftype, fid) = iprot.readFieldBegin()
12058 
      if ftype == TType.STOP:
12059 
        break
12060 
      if fid == 0:
3064 chandransh 12061 
        if ftype == TType.LIST:
12062 
          self.success = []
6000 mandeep.dh 12063 
          (_etype220, _size217) = iprot.readListBegin()
12064 
          for _i221 in xrange(_size217):
12065 
            _elem222 = Order()
12066 
            _elem222.read(iprot)
12067 
            self.success.append(_elem222)
3064 chandransh 12068 
          iprot.readListEnd()
1528 ankur.sing 12069 
        else:
12070 
          iprot.skip(ftype)
12071 
      else:
12072 
        iprot.skip(ftype)
12073 
      iprot.readFieldEnd()
12074 
    iprot.readStructEnd()
12075 
 
12076 
  def write(self, oprot):
12077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12079 
      return
3064 chandransh 12080 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12081 
    if self.success is not None:
3064 chandransh 12082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 12084 
      for iter223 in self.success:
12085 
        iter223.write(oprot)
3064 chandransh 12086 
      oprot.writeListEnd()
1528 ankur.sing 12087 
      oprot.writeFieldEnd()
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
3431 rajveer 12091 
  def validate(self):
12092 
    return
12093 
 
12094 
 
1528 ankur.sing 12095 
  def __repr__(self):
12096 
    L = ['%s=%r' % (key, value)
12097 
      for key, value in self.__dict__.iteritems()]
12098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12099 
 
12100 
  def __eq__(self, other):
12101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12102 
 
12103 
  def __ne__(self, other):
12104 
    return not (self == other)
12105 
 
1220 chandransh 12106 
class batchOrders_args:
12107 
  """
12108 
  Attributes:
12109 
   - warehouseId
12110 
  """
12111 
 
12112 
  thrift_spec = (
12113 
    None, # 0
12114 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12115 
  )
12116 
 
12117 
  def __init__(self, warehouseId=None,):
12118 
    self.warehouseId = warehouseId
12119 
 
12120 
  def read(self, iprot):
12121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12123 
      return
12124 
    iprot.readStructBegin()
12125 
    while True:
12126 
      (fname, ftype, fid) = iprot.readFieldBegin()
12127 
      if ftype == TType.STOP:
12128 
        break
12129 
      if fid == 1:
12130 
        if ftype == TType.I64:
12131 
          self.warehouseId = iprot.readI64();
12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      else:
12135 
        iprot.skip(ftype)
12136 
      iprot.readFieldEnd()
12137 
    iprot.readStructEnd()
12138 
 
12139 
  def write(self, oprot):
12140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12142 
      return
12143 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12144 
    if self.warehouseId is not None:
1220 chandransh 12145 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12146 
      oprot.writeI64(self.warehouseId)
12147 
      oprot.writeFieldEnd()
12148 
    oprot.writeFieldStop()
12149 
    oprot.writeStructEnd()
12150 
 
3431 rajveer 12151 
  def validate(self):
12152 
    return
12153 
 
12154 
 
1220 chandransh 12155 
  def __repr__(self):
12156 
    L = ['%s=%r' % (key, value)
12157 
      for key, value in self.__dict__.iteritems()]
12158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12159 
 
12160 
  def __eq__(self, other):
12161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12162 
 
12163 
  def __ne__(self, other):
12164 
    return not (self == other)
12165 
 
12166 
class batchOrders_result:
12167 
  """
12168 
  Attributes:
12169 
   - success
12170 
   - ex
12171 
  """
12172 
 
12173 
  thrift_spec = (
12174 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12175 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12176 
  )
12177 
 
12178 
  def __init__(self, success=None, ex=None,):
12179 
    self.success = success
12180 
    self.ex = ex
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 0:
12192 
        if ftype == TType.LIST:
12193 
          self.success = []
6000 mandeep.dh 12194 
          (_etype227, _size224) = iprot.readListBegin()
12195 
          for _i228 in xrange(_size224):
12196 
            _elem229 = Order()
12197 
            _elem229.read(iprot)
12198 
            self.success.append(_elem229)
1220 chandransh 12199 
          iprot.readListEnd()
12200 
        else:
12201 
          iprot.skip(ftype)
12202 
      elif fid == 1:
12203 
        if ftype == TType.STRUCT:
12204 
          self.ex = TransactionServiceException()
12205 
          self.ex.read(iprot)
12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
12217 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12218 
    if self.success is not None:
1220 chandransh 12219 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12220 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 12221 
      for iter230 in self.success:
12222 
        iter230.write(oprot)
1220 chandransh 12223 
      oprot.writeListEnd()
12224 
      oprot.writeFieldEnd()
3431 rajveer 12225 
    if self.ex is not None:
1220 chandransh 12226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12227 
      self.ex.write(oprot)
12228 
      oprot.writeFieldEnd()
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
3431 rajveer 12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
1220 chandransh 12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
1208 chandransh 12247 
class markOrderAsOutOfStock_args:
12248 
  """
12249 
  Attributes:
12250 
   - orderId
12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    None, # 0
12255 
    (1, TType.I64, 'orderId', None, None, ), # 1
12256 
  )
12257 
 
12258 
  def __init__(self, orderId=None,):
12259 
    self.orderId = orderId
12260 
 
12261 
  def read(self, iprot):
12262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12264 
      return
12265 
    iprot.readStructBegin()
12266 
    while True:
12267 
      (fname, ftype, fid) = iprot.readFieldBegin()
12268 
      if ftype == TType.STOP:
12269 
        break
12270 
      if fid == 1:
12271 
        if ftype == TType.I64:
12272 
          self.orderId = iprot.readI64();
12273 
        else:
12274 
          iprot.skip(ftype)
12275 
      else:
12276 
        iprot.skip(ftype)
12277 
      iprot.readFieldEnd()
12278 
    iprot.readStructEnd()
12279 
 
12280 
  def write(self, oprot):
12281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12283 
      return
12284 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12285 
    if self.orderId is not None:
1208 chandransh 12286 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12287 
      oprot.writeI64(self.orderId)
12288 
      oprot.writeFieldEnd()
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
3431 rajveer 12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
1208 chandransh 12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
12307 
class markOrderAsOutOfStock_result:
12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
   - ex
12312 
  """
12313 
 
12314 
  thrift_spec = (
12315 
    (0, TType.BOOL, 'success', None, None, ), # 0
12316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12317 
  )
12318 
 
12319 
  def __init__(self, success=None, ex=None,):
12320 
    self.success = success
12321 
    self.ex = ex
12322 
 
12323 
  def read(self, iprot):
12324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12326 
      return
12327 
    iprot.readStructBegin()
12328 
    while True:
12329 
      (fname, ftype, fid) = iprot.readFieldBegin()
12330 
      if ftype == TType.STOP:
12331 
        break
12332 
      if fid == 0:
12333 
        if ftype == TType.BOOL:
12334 
          self.success = iprot.readBool();
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      elif fid == 1:
12338 
        if ftype == TType.STRUCT:
12339 
          self.ex = TransactionServiceException()
12340 
          self.ex.read(iprot)
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      else:
12344 
        iprot.skip(ftype)
12345 
      iprot.readFieldEnd()
12346 
    iprot.readStructEnd()
12347 
 
12348 
  def write(self, oprot):
12349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12351 
      return
12352 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12353 
    if self.success is not None:
1208 chandransh 12354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12355 
      oprot.writeBool(self.success)
12356 
      oprot.writeFieldEnd()
3431 rajveer 12357 
    if self.ex is not None:
1208 chandransh 12358 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12359 
      self.ex.write(oprot)
12360 
      oprot.writeFieldEnd()
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
3431 rajveer 12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
1208 chandransh 12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
3064 chandransh 12379 
class verifyOrder_args:
759 chandransh 12380 
  """
12381 
  Attributes:
3064 chandransh 12382 
   - orderId
759 chandransh 12383 
  """
12384 
 
12385 
  thrift_spec = (
12386 
    None, # 0
3064 chandransh 12387 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12388 
  )
12389 
 
3064 chandransh 12390 
  def __init__(self, orderId=None,):
12391 
    self.orderId = orderId
759 chandransh 12392 
 
12393 
  def read(self, iprot):
12394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12396 
      return
12397 
    iprot.readStructBegin()
12398 
    while True:
12399 
      (fname, ftype, fid) = iprot.readFieldBegin()
12400 
      if ftype == TType.STOP:
12401 
        break
12402 
      if fid == 1:
12403 
        if ftype == TType.I64:
3064 chandransh 12404 
          self.orderId = iprot.readI64();
759 chandransh 12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      else:
12408 
        iprot.skip(ftype)
12409 
      iprot.readFieldEnd()
12410 
    iprot.readStructEnd()
12411 
 
12412 
  def write(self, oprot):
12413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12415 
      return
3064 chandransh 12416 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12417 
    if self.orderId is not None:
3064 chandransh 12418 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12419 
      oprot.writeI64(self.orderId)
759 chandransh 12420 
      oprot.writeFieldEnd()
12421 
    oprot.writeFieldStop()
12422 
    oprot.writeStructEnd()
12423 
 
3431 rajveer 12424 
  def validate(self):
12425 
    return
12426 
 
12427 
 
759 chandransh 12428 
  def __repr__(self):
12429 
    L = ['%s=%r' % (key, value)
12430 
      for key, value in self.__dict__.iteritems()]
12431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12432 
 
12433 
  def __eq__(self, other):
12434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12435 
 
12436 
  def __ne__(self, other):
12437 
    return not (self == other)
12438 
 
3064 chandransh 12439 
class verifyOrder_result:
759 chandransh 12440 
  """
12441 
  Attributes:
12442 
   - success
12443 
   - ex
12444 
  """
12445 
 
12446 
  thrift_spec = (
12447 
    (0, TType.BOOL, 'success', None, None, ), # 0
12448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12449 
  )
12450 
 
12451 
  def __init__(self, success=None, ex=None,):
12452 
    self.success = success
12453 
    self.ex = ex
12454 
 
12455 
  def read(self, iprot):
12456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12458 
      return
12459 
    iprot.readStructBegin()
12460 
    while True:
12461 
      (fname, ftype, fid) = iprot.readFieldBegin()
12462 
      if ftype == TType.STOP:
12463 
        break
12464 
      if fid == 0:
12465 
        if ftype == TType.BOOL:
12466 
          self.success = iprot.readBool();
12467 
        else:
12468 
          iprot.skip(ftype)
12469 
      elif fid == 1:
12470 
        if ftype == TType.STRUCT:
12471 
          self.ex = TransactionServiceException()
12472 
          self.ex.read(iprot)
12473 
        else:
12474 
          iprot.skip(ftype)
12475 
      else:
12476 
        iprot.skip(ftype)
12477 
      iprot.readFieldEnd()
12478 
    iprot.readStructEnd()
12479 
 
12480 
  def write(self, oprot):
12481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12483 
      return
3064 chandransh 12484 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12485 
    if self.success is not None:
759 chandransh 12486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12487 
      oprot.writeBool(self.success)
12488 
      oprot.writeFieldEnd()
3431 rajveer 12489 
    if self.ex is not None:
759 chandransh 12490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12491 
      self.ex.write(oprot)
12492 
      oprot.writeFieldEnd()
12493 
    oprot.writeFieldStop()
12494 
    oprot.writeStructEnd()
12495 
 
3431 rajveer 12496 
  def validate(self):
12497 
    return
12498 
 
12499 
 
759 chandransh 12500 
  def __repr__(self):
12501 
    L = ['%s=%r' % (key, value)
12502 
      for key, value in self.__dict__.iteritems()]
12503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12504 
 
12505 
  def __eq__(self, other):
12506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12507 
 
12508 
  def __ne__(self, other):
12509 
    return not (self == other)
12510 
 
3064 chandransh 12511 
class acceptOrder_args:
1113 chandransh 12512 
  """
12513 
  Attributes:
3064 chandransh 12514 
   - orderId
1113 chandransh 12515 
  """
12516 
 
12517 
  thrift_spec = (
12518 
    None, # 0
3064 chandransh 12519 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12520 
  )
12521 
 
3064 chandransh 12522 
  def __init__(self, orderId=None,):
12523 
    self.orderId = orderId
1113 chandransh 12524 
 
12525 
  def read(self, iprot):
12526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12528 
      return
12529 
    iprot.readStructBegin()
12530 
    while True:
12531 
      (fname, ftype, fid) = iprot.readFieldBegin()
12532 
      if ftype == TType.STOP:
12533 
        break
12534 
      if fid == 1:
12535 
        if ftype == TType.I64:
3064 chandransh 12536 
          self.orderId = iprot.readI64();
1113 chandransh 12537 
        else:
12538 
          iprot.skip(ftype)
12539 
      else:
12540 
        iprot.skip(ftype)
12541 
      iprot.readFieldEnd()
12542 
    iprot.readStructEnd()
12543 
 
12544 
  def write(self, oprot):
12545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12547 
      return
3064 chandransh 12548 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12549 
    if self.orderId is not None:
3064 chandransh 12550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12551 
      oprot.writeI64(self.orderId)
1113 chandransh 12552 
      oprot.writeFieldEnd()
12553 
    oprot.writeFieldStop()
12554 
    oprot.writeStructEnd()
12555 
 
3431 rajveer 12556 
  def validate(self):
12557 
    return
12558 
 
12559 
 
1113 chandransh 12560 
  def __repr__(self):
12561 
    L = ['%s=%r' % (key, value)
12562 
      for key, value in self.__dict__.iteritems()]
12563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12564 
 
12565 
  def __eq__(self, other):
12566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12567 
 
12568 
  def __ne__(self, other):
12569 
    return not (self == other)
12570 
 
3064 chandransh 12571 
class acceptOrder_result:
1113 chandransh 12572 
  """
12573 
  Attributes:
12574 
   - success
12575 
   - ex
12576 
  """
12577 
 
12578 
  thrift_spec = (
3064 chandransh 12579 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12581 
  )
12582 
 
12583 
  def __init__(self, success=None, ex=None,):
12584 
    self.success = success
12585 
    self.ex = ex
12586 
 
12587 
  def read(self, iprot):
12588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12590 
      return
12591 
    iprot.readStructBegin()
12592 
    while True:
12593 
      (fname, ftype, fid) = iprot.readFieldBegin()
12594 
      if ftype == TType.STOP:
12595 
        break
12596 
      if fid == 0:
3064 chandransh 12597 
        if ftype == TType.BOOL:
12598 
          self.success = iprot.readBool();
1113 chandransh 12599 
        else:
12600 
          iprot.skip(ftype)
12601 
      elif fid == 1:
12602 
        if ftype == TType.STRUCT:
12603 
          self.ex = TransactionServiceException()
12604 
          self.ex.read(iprot)
12605 
        else:
12606 
          iprot.skip(ftype)
12607 
      else:
12608 
        iprot.skip(ftype)
12609 
      iprot.readFieldEnd()
12610 
    iprot.readStructEnd()
12611 
 
12612 
  def write(self, oprot):
12613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12615 
      return
3064 chandransh 12616 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12617 
    if self.success is not None:
3064 chandransh 12618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12619 
      oprot.writeBool(self.success)
1113 chandransh 12620 
      oprot.writeFieldEnd()
3431 rajveer 12621 
    if self.ex is not None:
1113 chandransh 12622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12623 
      self.ex.write(oprot)
12624 
      oprot.writeFieldEnd()
12625 
    oprot.writeFieldStop()
12626 
    oprot.writeStructEnd()
12627 
 
3431 rajveer 12628 
  def validate(self):
12629 
    return
12630 
 
12631 
 
1113 chandransh 12632 
  def __repr__(self):
12633 
    L = ['%s=%r' % (key, value)
12634 
      for key, value in self.__dict__.iteritems()]
12635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12636 
 
12637 
  def __eq__(self, other):
12638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12639 
 
12640 
  def __ne__(self, other):
12641 
    return not (self == other)
12642 
 
3064 chandransh 12643 
class addBillingDetails_args:
1135 chandransh 12644 
  """
12645 
  Attributes:
3064 chandransh 12646 
   - orderId
12647 
   - invoice_number
4658 mandeep.dh 12648 
   - serialNumber
4283 anupam.sin 12649 
   - itemNumber
3064 chandransh 12650 
   - billed_by
4264 rajveer 12651 
   - jacketNumber
4283 anupam.sin 12652 
   - billingType
5110 mandeep.dh 12653 
   - fulfilmentWarehouseId
4763 rajveer 12654 
   - authorize
1135 chandransh 12655 
  """
12656 
 
12657 
  thrift_spec = (
12658 
    None, # 0
3064 chandransh 12659 
    (1, TType.I64, 'orderId', None, None, ), # 1
12660 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12661 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12662 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12663 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12664 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12665 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12666 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12667 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12668 
  )
12669 
 
5110 mandeep.dh 12670 
  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 12671 
    self.orderId = orderId
12672 
    self.invoice_number = invoice_number
4658 mandeep.dh 12673 
    self.serialNumber = serialNumber
4283 anupam.sin 12674 
    self.itemNumber = itemNumber
3064 chandransh 12675 
    self.billed_by = billed_by
4264 rajveer 12676 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12677 
    self.billingType = billingType
5110 mandeep.dh 12678 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12679 
    self.authorize = authorize
1135 chandransh 12680 
 
12681 
  def read(self, iprot):
12682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12684 
      return
12685 
    iprot.readStructBegin()
12686 
    while True:
12687 
      (fname, ftype, fid) = iprot.readFieldBegin()
12688 
      if ftype == TType.STOP:
12689 
        break
12690 
      if fid == 1:
12691 
        if ftype == TType.I64:
3064 chandransh 12692 
          self.orderId = iprot.readI64();
1135 chandransh 12693 
        else:
12694 
          iprot.skip(ftype)
12695 
      elif fid == 2:
3064 chandransh 12696 
        if ftype == TType.STRING:
12697 
          self.invoice_number = iprot.readString();
1135 chandransh 12698 
        else:
12699 
          iprot.skip(ftype)
3064 chandransh 12700 
      elif fid == 3:
5411 rajveer 12701 
        if ftype == TType.LIST:
12702 
          self.serialNumber = []
6000 mandeep.dh 12703 
          (_etype234, _size231) = iprot.readListBegin()
12704 
          for _i235 in xrange(_size231):
12705 
            _elem236 = iprot.readString();
12706 
            self.serialNumber.append(_elem236)
5411 rajveer 12707 
          iprot.readListEnd()
3064 chandransh 12708 
        else:
12709 
          iprot.skip(ftype)
12710 
      elif fid == 4:
5411 rajveer 12711 
        if ftype == TType.LIST:
12712 
          self.itemNumber = []
6000 mandeep.dh 12713 
          (_etype240, _size237) = iprot.readListBegin()
12714 
          for _i241 in xrange(_size237):
12715 
            _elem242 = iprot.readString();
12716 
            self.itemNumber.append(_elem242)
5411 rajveer 12717 
          iprot.readListEnd()
3064 chandransh 12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      elif fid == 5:
12721 
        if ftype == TType.STRING:
4283 anupam.sin 12722 
          self.billed_by = iprot.readString();
3064 chandransh 12723 
        else:
12724 
          iprot.skip(ftype)
12725 
      elif fid == 6:
12726 
        if ftype == TType.I64:
4283 anupam.sin 12727 
          self.jacketNumber = iprot.readI64();
12728 
        else:
12729 
          iprot.skip(ftype)
12730 
      elif fid == 7:
12731 
        if ftype == TType.I64:
3064 chandransh 12732 
          self.billingType = iprot.readI64();
12733 
        else:
12734 
          iprot.skip(ftype)
4283 anupam.sin 12735 
      elif fid == 8:
12736 
        if ftype == TType.I64:
5110 mandeep.dh 12737 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12738 
        else:
12739 
          iprot.skip(ftype)
4763 rajveer 12740 
      elif fid == 9:
12741 
        if ftype == TType.BOOL:
12742 
          self.authorize = iprot.readBool();
12743 
        else:
12744 
          iprot.skip(ftype)
1246 chandransh 12745 
      else:
12746 
        iprot.skip(ftype)
12747 
      iprot.readFieldEnd()
12748 
    iprot.readStructEnd()
12749 
 
12750 
  def write(self, oprot):
12751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12753 
      return
4283 anupam.sin 12754 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12755 
    if self.orderId is not None:
3064 chandransh 12756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12757 
      oprot.writeI64(self.orderId)
1246 chandransh 12758 
      oprot.writeFieldEnd()
4283 anupam.sin 12759 
    if self.invoice_number is not None:
12760 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12761 
      oprot.writeString(self.invoice_number)
1246 chandransh 12762 
      oprot.writeFieldEnd()
4658 mandeep.dh 12763 
    if self.serialNumber is not None:
5411 rajveer 12764 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12765 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6000 mandeep.dh 12766 
      for iter243 in self.serialNumber:
12767 
        oprot.writeString(iter243)
5411 rajveer 12768 
      oprot.writeListEnd()
3064 chandransh 12769 
      oprot.writeFieldEnd()
3431 rajveer 12770 
    if self.itemNumber is not None:
5411 rajveer 12771 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12772 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6000 mandeep.dh 12773 
      for iter244 in self.itemNumber:
12774 
        oprot.writeString(iter244)
5411 rajveer 12775 
      oprot.writeListEnd()
3064 chandransh 12776 
      oprot.writeFieldEnd()
4283 anupam.sin 12777 
    if self.billed_by is not None:
12778 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12779 
      oprot.writeString(self.billed_by)
3064 chandransh 12780 
      oprot.writeFieldEnd()
4283 anupam.sin 12781 
    if self.jacketNumber is not None:
12782 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12783 
      oprot.writeI64(self.jacketNumber)
12784 
      oprot.writeFieldEnd()
3431 rajveer 12785 
    if self.billingType is not None:
4283 anupam.sin 12786 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12787 
      oprot.writeI64(self.billingType)
12788 
      oprot.writeFieldEnd()
5110 mandeep.dh 12789 
    if self.fulfilmentWarehouseId is not None:
12790 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12791 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12792 
      oprot.writeFieldEnd()
4763 rajveer 12793 
    if self.authorize is not None:
12794 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12795 
      oprot.writeBool(self.authorize)
12796 
      oprot.writeFieldEnd()
1246 chandransh 12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
3431 rajveer 12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
1246 chandransh 12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
4283 anupam.sin 12815 
class addBillingDetails_result:
1246 chandransh 12816 
  """
12817 
  Attributes:
3064 chandransh 12818 
   - success
1246 chandransh 12819 
   - ex
12820 
  """
12821 
 
12822 
  thrift_spec = (
3064 chandransh 12823 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12825 
  )
12826 
 
3064 chandransh 12827 
  def __init__(self, success=None, ex=None,):
12828 
    self.success = success
1246 chandransh 12829 
    self.ex = ex
12830 
 
12831 
  def read(self, iprot):
12832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12834 
      return
12835 
    iprot.readStructBegin()
12836 
    while True:
12837 
      (fname, ftype, fid) = iprot.readFieldBegin()
12838 
      if ftype == TType.STOP:
12839 
        break
3064 chandransh 12840 
      if fid == 0:
12841 
        if ftype == TType.BOOL:
12842 
          self.success = iprot.readBool();
12843 
        else:
12844 
          iprot.skip(ftype)
12845 
      elif fid == 1:
1246 chandransh 12846 
        if ftype == TType.STRUCT:
12847 
          self.ex = TransactionServiceException()
12848 
          self.ex.read(iprot)
12849 
        else:
12850 
          iprot.skip(ftype)
12851 
      else:
12852 
        iprot.skip(ftype)
12853 
      iprot.readFieldEnd()
12854 
    iprot.readStructEnd()
12855 
 
12856 
  def write(self, oprot):
12857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12859 
      return
4283 anupam.sin 12860 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12861 
    if self.success is not None:
3064 chandransh 12862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12863 
      oprot.writeBool(self.success)
12864 
      oprot.writeFieldEnd()
3431 rajveer 12865 
    if self.ex is not None:
1246 chandransh 12866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12867 
      self.ex.write(oprot)
12868 
      oprot.writeFieldEnd()
12869 
    oprot.writeFieldStop()
12870 
    oprot.writeStructEnd()
12871 
 
3431 rajveer 12872 
  def validate(self):
12873 
    return
12874 
 
12875 
 
1246 chandransh 12876 
  def __repr__(self):
12877 
    L = ['%s=%r' % (key, value)
12878 
      for key, value in self.__dict__.iteritems()]
12879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12880 
 
12881 
  def __eq__(self, other):
12882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12883 
 
12884 
  def __ne__(self, other):
12885 
    return not (self == other)
12886 
 
4579 rajveer 12887 
class addInvoiceNumber_args:
12888 
  """
12889 
  Attributes:
12890 
   - orderId
12891 
   - invoiceNumber
4763 rajveer 12892 
   - color
4579 rajveer 12893 
  """
12894 
 
12895 
  thrift_spec = (
12896 
    None, # 0
12897 
    (1, TType.I64, 'orderId', None, None, ), # 1
12898 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12899 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12900 
  )
12901 
 
4763 rajveer 12902 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12903 
    self.orderId = orderId
12904 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12905 
    self.color = color
4579 rajveer 12906 
 
12907 
  def read(self, iprot):
12908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12910 
      return
12911 
    iprot.readStructBegin()
12912 
    while True:
12913 
      (fname, ftype, fid) = iprot.readFieldBegin()
12914 
      if ftype == TType.STOP:
12915 
        break
12916 
      if fid == 1:
12917 
        if ftype == TType.I64:
12918 
          self.orderId = iprot.readI64();
12919 
        else:
12920 
          iprot.skip(ftype)
12921 
      elif fid == 2:
12922 
        if ftype == TType.STRING:
12923 
          self.invoiceNumber = iprot.readString();
12924 
        else:
12925 
          iprot.skip(ftype)
4763 rajveer 12926 
      elif fid == 3:
12927 
        if ftype == TType.STRING:
12928 
          self.color = iprot.readString();
12929 
        else:
12930 
          iprot.skip(ftype)
4579 rajveer 12931 
      else:
12932 
        iprot.skip(ftype)
12933 
      iprot.readFieldEnd()
12934 
    iprot.readStructEnd()
12935 
 
12936 
  def write(self, oprot):
12937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12939 
      return
12940 
    oprot.writeStructBegin('addInvoiceNumber_args')
12941 
    if self.orderId is not None:
12942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12943 
      oprot.writeI64(self.orderId)
12944 
      oprot.writeFieldEnd()
12945 
    if self.invoiceNumber is not None:
12946 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12947 
      oprot.writeString(self.invoiceNumber)
12948 
      oprot.writeFieldEnd()
4763 rajveer 12949 
    if self.color is not None:
12950 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12951 
      oprot.writeString(self.color)
12952 
      oprot.writeFieldEnd()
4579 rajveer 12953 
    oprot.writeFieldStop()
12954 
    oprot.writeStructEnd()
12955 
 
12956 
  def validate(self):
12957 
    return
12958 
 
12959 
 
12960 
  def __repr__(self):
12961 
    L = ['%s=%r' % (key, value)
12962 
      for key, value in self.__dict__.iteritems()]
12963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12964 
 
12965 
  def __eq__(self, other):
12966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12967 
 
12968 
  def __ne__(self, other):
12969 
    return not (self == other)
12970 
 
12971 
class addInvoiceNumber_result:
12972 
  """
12973 
  Attributes:
12974 
   - ex
12975 
  """
12976 
 
12977 
  thrift_spec = (
12978 
    None, # 0
12979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12980 
  )
12981 
 
12982 
  def __init__(self, ex=None,):
12983 
    self.ex = ex
12984 
 
12985 
  def read(self, iprot):
12986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12988 
      return
12989 
    iprot.readStructBegin()
12990 
    while True:
12991 
      (fname, ftype, fid) = iprot.readFieldBegin()
12992 
      if ftype == TType.STOP:
12993 
        break
12994 
      if fid == 1:
12995 
        if ftype == TType.STRUCT:
12996 
          self.ex = TransactionServiceException()
12997 
          self.ex.read(iprot)
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('addInvoiceNumber_result')
13010 
    if self.ex is not None:
13011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13012 
      self.ex.write(oprot)
13013 
      oprot.writeFieldEnd()
13014 
    oprot.writeFieldStop()
13015 
    oprot.writeStructEnd()
13016 
 
13017 
  def validate(self):
13018 
    return
13019 
 
13020 
 
13021 
  def __repr__(self):
13022 
    L = ['%s=%r' % (key, value)
13023 
      for key, value in self.__dict__.iteritems()]
13024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13025 
 
13026 
  def __eq__(self, other):
13027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13028 
 
13029 
  def __ne__(self, other):
13030 
    return not (self == other)
13031 
 
4910 phani.kuma 13032 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13033 
  """
13034 
  Attributes:
3064 chandransh 13035 
   - warehouseId
1408 ankur.sing 13036 
   - providerId
3064 chandransh 13037 
   - cod
4910 phani.kuma 13038 
   - orderIds
1408 ankur.sing 13039 
  """
13040 
 
13041 
  thrift_spec = (
13042 
    None, # 0
3064 chandransh 13043 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13044 
    (2, TType.I64, 'providerId', None, None, ), # 2
13045 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13046 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13047 
  )
13048 
 
4910 phani.kuma 13049 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13050 
    self.warehouseId = warehouseId
1408 ankur.sing 13051 
    self.providerId = providerId
3064 chandransh 13052 
    self.cod = cod
4910 phani.kuma 13053 
    self.orderIds = orderIds
1408 ankur.sing 13054 
 
13055 
  def read(self, iprot):
13056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13058 
      return
13059 
    iprot.readStructBegin()
13060 
    while True:
13061 
      (fname, ftype, fid) = iprot.readFieldBegin()
13062 
      if ftype == TType.STOP:
13063 
        break
13064 
      if fid == 1:
13065 
        if ftype == TType.I64:
3064 chandransh 13066 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13067 
        else:
13068 
          iprot.skip(ftype)
13069 
      elif fid == 2:
13070 
        if ftype == TType.I64:
3064 chandransh 13071 
          self.providerId = iprot.readI64();
1408 ankur.sing 13072 
        else:
13073 
          iprot.skip(ftype)
3064 chandransh 13074 
      elif fid == 3:
13075 
        if ftype == TType.BOOL:
13076 
          self.cod = iprot.readBool();
13077 
        else:
13078 
          iprot.skip(ftype)
4910 phani.kuma 13079 
      elif fid == 4:
13080 
        if ftype == TType.LIST:
13081 
          self.orderIds = []
6000 mandeep.dh 13082 
          (_etype248, _size245) = iprot.readListBegin()
13083 
          for _i249 in xrange(_size245):
13084 
            _elem250 = iprot.readI64();
13085 
            self.orderIds.append(_elem250)
4910 phani.kuma 13086 
          iprot.readListEnd()
13087 
        else:
13088 
          iprot.skip(ftype)
1408 ankur.sing 13089 
      else:
13090 
        iprot.skip(ftype)
13091 
      iprot.readFieldEnd()
13092 
    iprot.readStructEnd()
13093 
 
13094 
  def write(self, oprot):
13095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13097 
      return
4910 phani.kuma 13098 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13099 
    if self.warehouseId is not None:
3064 chandransh 13100 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13101 
      oprot.writeI64(self.warehouseId)
13102 
      oprot.writeFieldEnd()
3431 rajveer 13103 
    if self.providerId is not None:
3064 chandransh 13104 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13105 
      oprot.writeI64(self.providerId)
13106 
      oprot.writeFieldEnd()
3431 rajveer 13107 
    if self.cod is not None:
3064 chandransh 13108 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13109 
      oprot.writeBool(self.cod)
1408 ankur.sing 13110 
      oprot.writeFieldEnd()
4910 phani.kuma 13111 
    if self.orderIds is not None:
13112 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13113 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 13114 
      for iter251 in self.orderIds:
13115 
        oprot.writeI64(iter251)
4910 phani.kuma 13116 
      oprot.writeListEnd()
13117 
      oprot.writeFieldEnd()
1408 ankur.sing 13118 
    oprot.writeFieldStop()
13119 
    oprot.writeStructEnd()
13120 
 
3431 rajveer 13121 
  def validate(self):
13122 
    return
13123 
 
13124 
 
1408 ankur.sing 13125 
  def __repr__(self):
13126 
    L = ['%s=%r' % (key, value)
13127 
      for key, value in self.__dict__.iteritems()]
13128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13129 
 
13130 
  def __eq__(self, other):
13131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13132 
 
13133 
  def __ne__(self, other):
13134 
    return not (self == other)
13135 
 
4910 phani.kuma 13136 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13137 
  """
13138 
  Attributes:
13139 
   - success
3064 chandransh 13140 
   - ex
1408 ankur.sing 13141 
  """
13142 
 
13143 
  thrift_spec = (
3064 chandransh 13144 
    (0, TType.BOOL, 'success', None, None, ), # 0
13145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13146 
  )
13147 
 
3064 chandransh 13148 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13149 
    self.success = success
3064 chandransh 13150 
    self.ex = ex
1408 ankur.sing 13151 
 
13152 
  def read(self, iprot):
13153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13155 
      return
13156 
    iprot.readStructBegin()
13157 
    while True:
13158 
      (fname, ftype, fid) = iprot.readFieldBegin()
13159 
      if ftype == TType.STOP:
13160 
        break
13161 
      if fid == 0:
3064 chandransh 13162 
        if ftype == TType.BOOL:
13163 
          self.success = iprot.readBool();
1408 ankur.sing 13164 
        else:
13165 
          iprot.skip(ftype)
3064 chandransh 13166 
      elif fid == 1:
13167 
        if ftype == TType.STRUCT:
13168 
          self.ex = TransactionServiceException()
13169 
          self.ex.read(iprot)
13170 
        else:
13171 
          iprot.skip(ftype)
1408 ankur.sing 13172 
      else:
13173 
        iprot.skip(ftype)
13174 
      iprot.readFieldEnd()
13175 
    iprot.readStructEnd()
13176 
 
13177 
  def write(self, oprot):
13178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13180 
      return
4910 phani.kuma 13181 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13182 
    if self.success is not None:
3064 chandransh 13183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13184 
      oprot.writeBool(self.success)
1408 ankur.sing 13185 
      oprot.writeFieldEnd()
3431 rajveer 13186 
    if self.ex is not None:
3064 chandransh 13187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13188 
      self.ex.write(oprot)
13189 
      oprot.writeFieldEnd()
1408 ankur.sing 13190 
    oprot.writeFieldStop()
13191 
    oprot.writeStructEnd()
13192 
 
3431 rajveer 13193 
  def validate(self):
13194 
    return
13195 
 
13196 
 
1408 ankur.sing 13197 
  def __repr__(self):
13198 
    L = ['%s=%r' % (key, value)
13199 
      for key, value in self.__dict__.iteritems()]
13200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13201 
 
13202 
  def __eq__(self, other):
13203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13204 
 
13205 
  def __ne__(self, other):
13206 
    return not (self == other)
13207 
 
5676 rajveer 13208 
class markOrdersAsReturnedFromStore_args:
13209 
  """
13210 
  Attributes:
13211 
   - providerId
13212 
   - orderIds
5713 rajveer 13213 
   - awbs
5676 rajveer 13214 
  """
13215 
 
13216 
  thrift_spec = (
13217 
    None, # 0
13218 
    (1, TType.I64, 'providerId', None, None, ), # 1
13219 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13220 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13221 
  )
13222 
 
5713 rajveer 13223 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13224 
    self.providerId = providerId
13225 
    self.orderIds = orderIds
5713 rajveer 13226 
    self.awbs = awbs
5676 rajveer 13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.I64:
13239 
          self.providerId = iprot.readI64();
13240 
        else:
13241 
          iprot.skip(ftype)
13242 
      elif fid == 2:
13243 
        if ftype == TType.LIST:
13244 
          self.orderIds = []
6000 mandeep.dh 13245 
          (_etype255, _size252) = iprot.readListBegin()
13246 
          for _i256 in xrange(_size252):
13247 
            _elem257 = iprot.readI64();
13248 
            self.orderIds.append(_elem257)
5676 rajveer 13249 
          iprot.readListEnd()
13250 
        else:
13251 
          iprot.skip(ftype)
5713 rajveer 13252 
      elif fid == 3:
13253 
        if ftype == TType.LIST:
13254 
          self.awbs = []
6000 mandeep.dh 13255 
          (_etype261, _size258) = iprot.readListBegin()
13256 
          for _i262 in xrange(_size258):
13257 
            _elem263 = iprot.readString();
13258 
            self.awbs.append(_elem263)
5713 rajveer 13259 
          iprot.readListEnd()
13260 
        else:
13261 
          iprot.skip(ftype)
5676 rajveer 13262 
      else:
13263 
        iprot.skip(ftype)
13264 
      iprot.readFieldEnd()
13265 
    iprot.readStructEnd()
13266 
 
13267 
  def write(self, oprot):
13268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13270 
      return
13271 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13272 
    if self.providerId is not None:
13273 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13274 
      oprot.writeI64(self.providerId)
13275 
      oprot.writeFieldEnd()
13276 
    if self.orderIds is not None:
13277 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13278 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 13279 
      for iter264 in self.orderIds:
13280 
        oprot.writeI64(iter264)
5676 rajveer 13281 
      oprot.writeListEnd()
13282 
      oprot.writeFieldEnd()
5713 rajveer 13283 
    if self.awbs is not None:
13284 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13285 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6000 mandeep.dh 13286 
      for iter265 in self.awbs:
13287 
        oprot.writeString(iter265)
5713 rajveer 13288 
      oprot.writeListEnd()
13289 
      oprot.writeFieldEnd()
5676 rajveer 13290 
    oprot.writeFieldStop()
13291 
    oprot.writeStructEnd()
13292 
 
13293 
  def validate(self):
13294 
    return
13295 
 
13296 
 
13297 
  def __repr__(self):
13298 
    L = ['%s=%r' % (key, value)
13299 
      for key, value in self.__dict__.iteritems()]
13300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13301 
 
13302 
  def __eq__(self, other):
13303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13304 
 
13305 
  def __ne__(self, other):
13306 
    return not (self == other)
13307 
 
13308 
class markOrdersAsReturnedFromStore_result:
13309 
  """
13310 
  Attributes:
13311 
   - success
13312 
   - ex
13313 
  """
13314 
 
13315 
  thrift_spec = (
13316 
    (0, TType.BOOL, 'success', None, None, ), # 0
13317 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13318 
  )
13319 
 
13320 
  def __init__(self, success=None, ex=None,):
13321 
    self.success = success
13322 
    self.ex = ex
13323 
 
13324 
  def read(self, iprot):
13325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13327 
      return
13328 
    iprot.readStructBegin()
13329 
    while True:
13330 
      (fname, ftype, fid) = iprot.readFieldBegin()
13331 
      if ftype == TType.STOP:
13332 
        break
13333 
      if fid == 0:
13334 
        if ftype == TType.BOOL:
13335 
          self.success = iprot.readBool();
13336 
        else:
13337 
          iprot.skip(ftype)
13338 
      elif fid == 1:
13339 
        if ftype == TType.STRUCT:
13340 
          self.ex = TransactionServiceException()
13341 
          self.ex.read(iprot)
13342 
        else:
13343 
          iprot.skip(ftype)
13344 
      else:
13345 
        iprot.skip(ftype)
13346 
      iprot.readFieldEnd()
13347 
    iprot.readStructEnd()
13348 
 
13349 
  def write(self, oprot):
13350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13352 
      return
13353 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13354 
    if self.success is not None:
13355 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13356 
      oprot.writeBool(self.success)
13357 
      oprot.writeFieldEnd()
13358 
    if self.ex is not None:
13359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13360 
      self.ex.write(oprot)
13361 
      oprot.writeFieldEnd()
13362 
    oprot.writeFieldStop()
13363 
    oprot.writeStructEnd()
13364 
 
13365 
  def validate(self):
13366 
    return
13367 
 
13368 
 
13369 
  def __repr__(self):
13370 
    L = ['%s=%r' % (key, value)
13371 
      for key, value in self.__dict__.iteritems()]
13372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13373 
 
13374 
  def __eq__(self, other):
13375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13376 
 
13377 
  def __ne__(self, other):
13378 
    return not (self == other)
13379 
 
4910 phani.kuma 13380 
class markOrdersAsPickedUp_args:
4410 rajveer 13381 
  """
13382 
  Attributes:
13383 
   - providerId
4910 phani.kuma 13384 
   - pickupDetails
4410 rajveer 13385 
  """
13386 
 
13387 
  thrift_spec = (
13388 
    None, # 0
4910 phani.kuma 13389 
    (1, TType.I64, 'providerId', None, None, ), # 1
13390 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13391 
  )
13392 
 
4910 phani.kuma 13393 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13394 
    self.providerId = providerId
4910 phani.kuma 13395 
    self.pickupDetails = pickupDetails
4410 rajveer 13396 
 
13397 
  def read(self, iprot):
13398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13400 
      return
13401 
    iprot.readStructBegin()
13402 
    while True:
13403 
      (fname, ftype, fid) = iprot.readFieldBegin()
13404 
      if ftype == TType.STOP:
13405 
        break
13406 
      if fid == 1:
13407 
        if ftype == TType.I64:
4910 phani.kuma 13408 
          self.providerId = iprot.readI64();
4410 rajveer 13409 
        else:
13410 
          iprot.skip(ftype)
13411 
      elif fid == 2:
4910 phani.kuma 13412 
        if ftype == TType.MAP:
13413 
          self.pickupDetails = {}
6000 mandeep.dh 13414 
          (_ktype267, _vtype268, _size266 ) = iprot.readMapBegin()
13415 
          for _i270 in xrange(_size266):
13416 
            _key271 = iprot.readString();
13417 
            _val272 = iprot.readString();
13418 
            self.pickupDetails[_key271] = _val272
4910 phani.kuma 13419 
          iprot.readMapEnd()
4410 rajveer 13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      else:
13423 
        iprot.skip(ftype)
13424 
      iprot.readFieldEnd()
13425 
    iprot.readStructEnd()
13426 
 
13427 
  def write(self, oprot):
13428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13430 
      return
4910 phani.kuma 13431 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13432 
    if self.providerId is not None:
4910 phani.kuma 13433 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13434 
      oprot.writeI64(self.providerId)
13435 
      oprot.writeFieldEnd()
4910 phani.kuma 13436 
    if self.pickupDetails is not None:
13437 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13438 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 13439 
      for kiter273,viter274 in self.pickupDetails.items():
13440 
        oprot.writeString(kiter273)
13441 
        oprot.writeString(viter274)
4910 phani.kuma 13442 
      oprot.writeMapEnd()
4410 rajveer 13443 
      oprot.writeFieldEnd()
13444 
    oprot.writeFieldStop()
13445 
    oprot.writeStructEnd()
13446 
 
13447 
  def validate(self):
13448 
    return
13449 
 
13450 
 
13451 
  def __repr__(self):
13452 
    L = ['%s=%r' % (key, value)
13453 
      for key, value in self.__dict__.iteritems()]
13454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13455 
 
13456 
  def __eq__(self, other):
13457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13458 
 
13459 
  def __ne__(self, other):
13460 
    return not (self == other)
13461 
 
4910 phani.kuma 13462 
class markOrdersAsPickedUp_result:
4410 rajveer 13463 
  """
13464 
  Attributes:
13465 
   - ex
13466 
  """
13467 
 
13468 
  thrift_spec = (
4910 phani.kuma 13469 
    None, # 0
4410 rajveer 13470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13471 
  )
13472 
 
4910 phani.kuma 13473 
  def __init__(self, ex=None,):
4410 rajveer 13474 
    self.ex = ex
13475 
 
13476 
  def read(self, iprot):
13477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13479 
      return
13480 
    iprot.readStructBegin()
13481 
    while True:
13482 
      (fname, ftype, fid) = iprot.readFieldBegin()
13483 
      if ftype == TType.STOP:
13484 
        break
4910 phani.kuma 13485 
      if fid == 1:
4410 rajveer 13486 
        if ftype == TType.STRUCT:
13487 
          self.ex = TransactionServiceException()
13488 
          self.ex.read(iprot)
13489 
        else:
13490 
          iprot.skip(ftype)
13491 
      else:
13492 
        iprot.skip(ftype)
13493 
      iprot.readFieldEnd()
13494 
    iprot.readStructEnd()
13495 
 
13496 
  def write(self, oprot):
13497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13499 
      return
4910 phani.kuma 13500 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13501 
    if self.ex is not None:
13502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13503 
      self.ex.write(oprot)
13504 
      oprot.writeFieldEnd()
13505 
    oprot.writeFieldStop()
13506 
    oprot.writeStructEnd()
13507 
 
13508 
  def validate(self):
13509 
    return
13510 
 
13511 
 
13512 
  def __repr__(self):
13513 
    L = ['%s=%r' % (key, value)
13514 
      for key, value in self.__dict__.iteritems()]
13515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13516 
 
13517 
  def __eq__(self, other):
13518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13519 
 
13520 
  def __ne__(self, other):
13521 
    return not (self == other)
13522 
 
4910 phani.kuma 13523 
class getOrdersNotPickedUp_args:
304 ashish 13524 
  """
13525 
  Attributes:
3064 chandransh 13526 
   - providerId
304 ashish 13527 
  """
94 ashish 13528 
 
304 ashish 13529 
  thrift_spec = (
13530 
    None, # 0
3064 chandransh 13531 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13532 
  )
13533 
 
4910 phani.kuma 13534 
  def __init__(self, providerId=None,):
3064 chandransh 13535 
    self.providerId = providerId
304 ashish 13536 
 
13537 
  def read(self, iprot):
13538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13540 
      return
13541 
    iprot.readStructBegin()
13542 
    while True:
13543 
      (fname, ftype, fid) = iprot.readFieldBegin()
13544 
      if ftype == TType.STOP:
13545 
        break
13546 
      if fid == 1:
13547 
        if ftype == TType.I64:
3064 chandransh 13548 
          self.providerId = iprot.readI64();
304 ashish 13549 
        else:
13550 
          iprot.skip(ftype)
13551 
      else:
13552 
        iprot.skip(ftype)
13553 
      iprot.readFieldEnd()
13554 
    iprot.readStructEnd()
13555 
 
13556 
  def write(self, oprot):
13557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13559 
      return
4910 phani.kuma 13560 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13561 
    if self.providerId is not None:
3064 chandransh 13562 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13563 
      oprot.writeI64(self.providerId)
304 ashish 13564 
      oprot.writeFieldEnd()
13565 
    oprot.writeFieldStop()
13566 
    oprot.writeStructEnd()
13567 
 
3431 rajveer 13568 
  def validate(self):
13569 
    return
13570 
 
13571 
 
304 ashish 13572 
  def __repr__(self):
13573 
    L = ['%s=%r' % (key, value)
13574 
      for key, value in self.__dict__.iteritems()]
13575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13576 
 
13577 
  def __eq__(self, other):
13578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13579 
 
13580 
  def __ne__(self, other):
13581 
    return not (self == other)
13582 
 
4910 phani.kuma 13583 
class getOrdersNotPickedUp_result:
304 ashish 13584 
  """
13585 
  Attributes:
13586 
   - success
13587 
  """
13588 
 
13589 
  thrift_spec = (
3064 chandransh 13590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13591 
  )
13592 
 
4910 phani.kuma 13593 
  def __init__(self, success=None,):
304 ashish 13594 
    self.success = success
13595 
 
13596 
  def read(self, iprot):
13597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13599 
      return
13600 
    iprot.readStructBegin()
13601 
    while True:
13602 
      (fname, ftype, fid) = iprot.readFieldBegin()
13603 
      if ftype == TType.STOP:
13604 
        break
13605 
      if fid == 0:
13606 
        if ftype == TType.LIST:
13607 
          self.success = []
6000 mandeep.dh 13608 
          (_etype278, _size275) = iprot.readListBegin()
13609 
          for _i279 in xrange(_size275):
13610 
            _elem280 = Order()
13611 
            _elem280.read(iprot)
13612 
            self.success.append(_elem280)
304 ashish 13613 
          iprot.readListEnd()
13614 
        else:
13615 
          iprot.skip(ftype)
13616 
      else:
13617 
        iprot.skip(ftype)
13618 
      iprot.readFieldEnd()
13619 
    iprot.readStructEnd()
13620 
 
13621 
  def write(self, oprot):
13622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13624 
      return
4910 phani.kuma 13625 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13626 
    if self.success is not None:
304 ashish 13627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 13629 
      for iter281 in self.success:
13630 
        iter281.write(oprot)
304 ashish 13631 
      oprot.writeListEnd()
13632 
      oprot.writeFieldEnd()
13633 
    oprot.writeFieldStop()
13634 
    oprot.writeStructEnd()
13635 
 
3431 rajveer 13636 
  def validate(self):
13637 
    return
13638 
 
13639 
 
304 ashish 13640 
  def __repr__(self):
13641 
    L = ['%s=%r' % (key, value)
13642 
      for key, value in self.__dict__.iteritems()]
13643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13644 
 
13645 
  def __eq__(self, other):
13646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13647 
 
13648 
  def __ne__(self, other):
13649 
    return not (self == other)
13650 
 
3064 chandransh 13651 
class markOrdersAsDelivered_args:
304 ashish 13652 
  """
13653 
  Attributes:
3064 chandransh 13654 
   - providerId
13655 
   - deliveredOrders
304 ashish 13656 
  """
13657 
 
13658 
  thrift_spec = (
13659 
    None, # 0
3064 chandransh 13660 
    (1, TType.I64, 'providerId', None, None, ), # 1
13661 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13662 
  )
13663 
 
3064 chandransh 13664 
  def __init__(self, providerId=None, deliveredOrders=None,):
13665 
    self.providerId = providerId
13666 
    self.deliveredOrders = deliveredOrders
304 ashish 13667 
 
13668 
  def read(self, iprot):
13669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13671 
      return
13672 
    iprot.readStructBegin()
13673 
    while True:
13674 
      (fname, ftype, fid) = iprot.readFieldBegin()
13675 
      if ftype == TType.STOP:
13676 
        break
13677 
      if fid == 1:
13678 
        if ftype == TType.I64:
3064 chandransh 13679 
          self.providerId = iprot.readI64();
304 ashish 13680 
        else:
13681 
          iprot.skip(ftype)
13682 
      elif fid == 2:
3064 chandransh 13683 
        if ftype == TType.MAP:
13684 
          self.deliveredOrders = {}
6000 mandeep.dh 13685 
          (_ktype283, _vtype284, _size282 ) = iprot.readMapBegin()
13686 
          for _i286 in xrange(_size282):
13687 
            _key287 = iprot.readString();
13688 
            _val288 = iprot.readString();
13689 
            self.deliveredOrders[_key287] = _val288
3064 chandransh 13690 
          iprot.readMapEnd()
304 ashish 13691 
        else:
13692 
          iprot.skip(ftype)
13693 
      else:
13694 
        iprot.skip(ftype)
13695 
      iprot.readFieldEnd()
13696 
    iprot.readStructEnd()
13697 
 
13698 
  def write(self, oprot):
13699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13701 
      return
3064 chandransh 13702 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13703 
    if self.providerId is not None:
3064 chandransh 13704 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13705 
      oprot.writeI64(self.providerId)
304 ashish 13706 
      oprot.writeFieldEnd()
3431 rajveer 13707 
    if self.deliveredOrders is not None:
3064 chandransh 13708 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13709 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6000 mandeep.dh 13710 
      for kiter289,viter290 in self.deliveredOrders.items():
13711 
        oprot.writeString(kiter289)
13712 
        oprot.writeString(viter290)
3064 chandransh 13713 
      oprot.writeMapEnd()
304 ashish 13714 
      oprot.writeFieldEnd()
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
3431 rajveer 13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
304 ashish 13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
13732 
 
3064 chandransh 13733 
class markOrdersAsDelivered_result:
13734 
  """
13735 
  Attributes:
13736 
   - ex
13737 
  """
304 ashish 13738 
 
13739 
  thrift_spec = (
3064 chandransh 13740 
    None, # 0
13741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13742 
  )
13743 
 
3064 chandransh 13744 
  def __init__(self, ex=None,):
13745 
    self.ex = ex
304 ashish 13746 
 
1596 ankur.sing 13747 
  def read(self, iprot):
13748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13750 
      return
13751 
    iprot.readStructBegin()
13752 
    while True:
13753 
      (fname, ftype, fid) = iprot.readFieldBegin()
13754 
      if ftype == TType.STOP:
13755 
        break
3064 chandransh 13756 
      if fid == 1:
13757 
        if ftype == TType.STRUCT:
13758 
          self.ex = TransactionServiceException()
13759 
          self.ex.read(iprot)
13760 
        else:
13761 
          iprot.skip(ftype)
1596 ankur.sing 13762 
      else:
13763 
        iprot.skip(ftype)
13764 
      iprot.readFieldEnd()
13765 
    iprot.readStructEnd()
13766 
 
13767 
  def write(self, oprot):
13768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13770 
      return
3064 chandransh 13771 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13772 
    if self.ex is not None:
3064 chandransh 13773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13774 
      self.ex.write(oprot)
13775 
      oprot.writeFieldEnd()
1596 ankur.sing 13776 
    oprot.writeFieldStop()
13777 
    oprot.writeStructEnd()
13778 
 
3431 rajveer 13779 
  def validate(self):
13780 
    return
13781 
 
13782 
 
1596 ankur.sing 13783 
  def __repr__(self):
13784 
    L = ['%s=%r' % (key, value)
13785 
      for key, value in self.__dict__.iteritems()]
13786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13787 
 
13788 
  def __eq__(self, other):
13789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13790 
 
13791 
  def __ne__(self, other):
13792 
    return not (self == other)
13793 
 
4910 phani.kuma 13794 
class markAsRTOrders_args:
1596 ankur.sing 13795 
  """
13796 
  Attributes:
3064 chandransh 13797 
   - providerId
13798 
   - returnedOrders
1596 ankur.sing 13799 
  """
13800 
 
13801 
  thrift_spec = (
3064 chandransh 13802 
    None, # 0
13803 
    (1, TType.I64, 'providerId', None, None, ), # 1
13804 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13805 
  )
13806 
 
3064 chandransh 13807 
  def __init__(self, providerId=None, returnedOrders=None,):
13808 
    self.providerId = providerId
13809 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13810 
 
13811 
  def read(self, iprot):
13812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13814 
      return
13815 
    iprot.readStructBegin()
13816 
    while True:
13817 
      (fname, ftype, fid) = iprot.readFieldBegin()
13818 
      if ftype == TType.STOP:
13819 
        break
3064 chandransh 13820 
      if fid == 1:
1596 ankur.sing 13821 
        if ftype == TType.I64:
3064 chandransh 13822 
          self.providerId = iprot.readI64();
1596 ankur.sing 13823 
        else:
13824 
          iprot.skip(ftype)
3064 chandransh 13825 
      elif fid == 2:
13826 
        if ftype == TType.MAP:
13827 
          self.returnedOrders = {}
6000 mandeep.dh 13828 
          (_ktype292, _vtype293, _size291 ) = iprot.readMapBegin()
13829 
          for _i295 in xrange(_size291):
13830 
            _key296 = iprot.readString();
13831 
            _val297 = iprot.readString();
13832 
            self.returnedOrders[_key296] = _val297
3064 chandransh 13833 
          iprot.readMapEnd()
13834 
        else:
13835 
          iprot.skip(ftype)
1596 ankur.sing 13836 
      else:
13837 
        iprot.skip(ftype)
13838 
      iprot.readFieldEnd()
13839 
    iprot.readStructEnd()
13840 
 
13841 
  def write(self, oprot):
13842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13844 
      return
4910 phani.kuma 13845 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13846 
    if self.providerId is not None:
3064 chandransh 13847 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13848 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13849 
      oprot.writeFieldEnd()
3431 rajveer 13850 
    if self.returnedOrders is not None:
3064 chandransh 13851 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13852 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6000 mandeep.dh 13853 
      for kiter298,viter299 in self.returnedOrders.items():
13854 
        oprot.writeString(kiter298)
13855 
        oprot.writeString(viter299)
3064 chandransh 13856 
      oprot.writeMapEnd()
13857 
      oprot.writeFieldEnd()
1596 ankur.sing 13858 
    oprot.writeFieldStop()
13859 
    oprot.writeStructEnd()
13860 
 
3431 rajveer 13861 
  def validate(self):
13862 
    return
13863 
 
13864 
 
1596 ankur.sing 13865 
  def __repr__(self):
13866 
    L = ['%s=%r' % (key, value)
13867 
      for key, value in self.__dict__.iteritems()]
13868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13869 
 
13870 
  def __eq__(self, other):
13871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13872 
 
13873 
  def __ne__(self, other):
13874 
    return not (self == other)
13875 
 
4910 phani.kuma 13876 
class markAsRTOrders_result:
3064 chandransh 13877 
  """
13878 
  Attributes:
13879 
   - ex
13880 
  """
1596 ankur.sing 13881 
 
1627 ankur.sing 13882 
  thrift_spec = (
3064 chandransh 13883 
    None, # 0
13884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13885 
  )
13886 
 
3064 chandransh 13887 
  def __init__(self, ex=None,):
13888 
    self.ex = ex
13889 
 
1627 ankur.sing 13890 
  def read(self, iprot):
13891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13893 
      return
13894 
    iprot.readStructBegin()
13895 
    while True:
13896 
      (fname, ftype, fid) = iprot.readFieldBegin()
13897 
      if ftype == TType.STOP:
13898 
        break
3064 chandransh 13899 
      if fid == 1:
13900 
        if ftype == TType.STRUCT:
13901 
          self.ex = TransactionServiceException()
13902 
          self.ex.read(iprot)
13903 
        else:
13904 
          iprot.skip(ftype)
1627 ankur.sing 13905 
      else:
13906 
        iprot.skip(ftype)
13907 
      iprot.readFieldEnd()
13908 
    iprot.readStructEnd()
13909 
 
13910 
  def write(self, oprot):
13911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13913 
      return
4910 phani.kuma 13914 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13915 
    if self.ex is not None:
3064 chandransh 13916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13917 
      self.ex.write(oprot)
13918 
      oprot.writeFieldEnd()
1627 ankur.sing 13919 
    oprot.writeFieldStop()
13920 
    oprot.writeStructEnd()
13921 
 
3431 rajveer 13922 
  def validate(self):
13923 
    return
13924 
 
13925 
 
1627 ankur.sing 13926 
  def __repr__(self):
13927 
    L = ['%s=%r' % (key, value)
13928 
      for key, value in self.__dict__.iteritems()]
13929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13930 
 
13931 
  def __eq__(self, other):
13932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13933 
 
13934 
  def __ne__(self, other):
13935 
    return not (self == other)
13936 
 
4910 phani.kuma 13937 
class getRTOrders_args:
13938 
  """
13939 
  Attributes:
13940 
   - providerId
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    None, # 0
13945 
    (1, TType.I64, 'providerId', None, None, ), # 1
13946 
  )
13947 
 
13948 
  def __init__(self, providerId=None,):
13949 
    self.providerId = providerId
13950 
 
13951 
  def read(self, iprot):
13952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13954 
      return
13955 
    iprot.readStructBegin()
13956 
    while True:
13957 
      (fname, ftype, fid) = iprot.readFieldBegin()
13958 
      if ftype == TType.STOP:
13959 
        break
13960 
      if fid == 1:
13961 
        if ftype == TType.I64:
13962 
          self.providerId = iprot.readI64();
13963 
        else:
13964 
          iprot.skip(ftype)
13965 
      else:
13966 
        iprot.skip(ftype)
13967 
      iprot.readFieldEnd()
13968 
    iprot.readStructEnd()
13969 
 
13970 
  def write(self, oprot):
13971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13973 
      return
13974 
    oprot.writeStructBegin('getRTOrders_args')
13975 
    if self.providerId is not None:
13976 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13977 
      oprot.writeI64(self.providerId)
13978 
      oprot.writeFieldEnd()
13979 
    oprot.writeFieldStop()
13980 
    oprot.writeStructEnd()
13981 
 
13982 
  def validate(self):
13983 
    return
13984 
 
13985 
 
13986 
  def __repr__(self):
13987 
    L = ['%s=%r' % (key, value)
13988 
      for key, value in self.__dict__.iteritems()]
13989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13990 
 
13991 
  def __eq__(self, other):
13992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13993 
 
13994 
  def __ne__(self, other):
13995 
    return not (self == other)
13996 
 
13997 
class getRTOrders_result:
13998 
  """
13999 
  Attributes:
14000 
   - success
14001 
  """
14002 
 
14003 
  thrift_spec = (
14004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14005 
  )
14006 
 
14007 
  def __init__(self, success=None,):
14008 
    self.success = success
14009 
 
14010 
  def read(self, iprot):
14011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14013 
      return
14014 
    iprot.readStructBegin()
14015 
    while True:
14016 
      (fname, ftype, fid) = iprot.readFieldBegin()
14017 
      if ftype == TType.STOP:
14018 
        break
14019 
      if fid == 0:
14020 
        if ftype == TType.LIST:
14021 
          self.success = []
6000 mandeep.dh 14022 
          (_etype303, _size300) = iprot.readListBegin()
14023 
          for _i304 in xrange(_size300):
14024 
            _elem305 = Order()
14025 
            _elem305.read(iprot)
14026 
            self.success.append(_elem305)
4910 phani.kuma 14027 
          iprot.readListEnd()
14028 
        else:
14029 
          iprot.skip(ftype)
14030 
      else:
14031 
        iprot.skip(ftype)
14032 
      iprot.readFieldEnd()
14033 
    iprot.readStructEnd()
14034 
 
14035 
  def write(self, oprot):
14036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14038 
      return
14039 
    oprot.writeStructBegin('getRTOrders_result')
14040 
    if self.success is not None:
14041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14043 
      for iter306 in self.success:
14044 
        iter306.write(oprot)
4910 phani.kuma 14045 
      oprot.writeListEnd()
14046 
      oprot.writeFieldEnd()
14047 
    oprot.writeFieldStop()
14048 
    oprot.writeStructEnd()
14049 
 
14050 
  def validate(self):
14051 
    return
14052 
 
14053 
 
14054 
  def __repr__(self):
14055 
    L = ['%s=%r' % (key, value)
14056 
      for key, value in self.__dict__.iteritems()]
14057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14058 
 
14059 
  def __eq__(self, other):
14060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14061 
 
14062 
  def __ne__(self, other):
14063 
    return not (self == other)
14064 
 
3064 chandransh 14065 
class updateNonDeliveryReason_args:
1627 ankur.sing 14066 
  """
14067 
  Attributes:
3064 chandransh 14068 
   - providerId
14069 
   - undeliveredOrders
1627 ankur.sing 14070 
  """
14071 
 
14072 
  thrift_spec = (
3064 chandransh 14073 
    None, # 0
14074 
    (1, TType.I64, 'providerId', None, None, ), # 1
14075 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14076 
  )
14077 
 
3064 chandransh 14078 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14079 
    self.providerId = providerId
14080 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14081 
 
14082 
  def read(self, iprot):
14083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14085 
      return
14086 
    iprot.readStructBegin()
14087 
    while True:
14088 
      (fname, ftype, fid) = iprot.readFieldBegin()
14089 
      if ftype == TType.STOP:
14090 
        break
3064 chandransh 14091 
      if fid == 1:
1627 ankur.sing 14092 
        if ftype == TType.I64:
3064 chandransh 14093 
          self.providerId = iprot.readI64();
1627 ankur.sing 14094 
        else:
14095 
          iprot.skip(ftype)
3064 chandransh 14096 
      elif fid == 2:
14097 
        if ftype == TType.MAP:
14098 
          self.undeliveredOrders = {}
6000 mandeep.dh 14099 
          (_ktype308, _vtype309, _size307 ) = iprot.readMapBegin()
14100 
          for _i311 in xrange(_size307):
14101 
            _key312 = iprot.readString();
14102 
            _val313 = iprot.readString();
14103 
            self.undeliveredOrders[_key312] = _val313
3064 chandransh 14104 
          iprot.readMapEnd()
14105 
        else:
14106 
          iprot.skip(ftype)
1627 ankur.sing 14107 
      else:
14108 
        iprot.skip(ftype)
14109 
      iprot.readFieldEnd()
14110 
    iprot.readStructEnd()
14111 
 
14112 
  def write(self, oprot):
14113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14115 
      return
3064 chandransh 14116 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14117 
    if self.providerId is not None:
3064 chandransh 14118 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14119 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14120 
      oprot.writeFieldEnd()
3431 rajveer 14121 
    if self.undeliveredOrders is not None:
3064 chandransh 14122 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14123 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6000 mandeep.dh 14124 
      for kiter314,viter315 in self.undeliveredOrders.items():
14125 
        oprot.writeString(kiter314)
14126 
        oprot.writeString(viter315)
3064 chandransh 14127 
      oprot.writeMapEnd()
14128 
      oprot.writeFieldEnd()
1627 ankur.sing 14129 
    oprot.writeFieldStop()
14130 
    oprot.writeStructEnd()
14131 
 
3431 rajveer 14132 
  def validate(self):
14133 
    return
14134 
 
14135 
 
1627 ankur.sing 14136 
  def __repr__(self):
14137 
    L = ['%s=%r' % (key, value)
14138 
      for key, value in self.__dict__.iteritems()]
14139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14140 
 
14141 
  def __eq__(self, other):
14142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14143 
 
14144 
  def __ne__(self, other):
14145 
    return not (self == other)
14146 
 
3064 chandransh 14147 
class updateNonDeliveryReason_result:
1627 ankur.sing 14148 
  """
14149 
  Attributes:
3064 chandransh 14150 
   - ex
1627 ankur.sing 14151 
  """
14152 
 
14153 
  thrift_spec = (
4910 phani.kuma 14154 
    None, # 0
3064 chandransh 14155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14156 
  )
14157 
 
4910 phani.kuma 14158 
  def __init__(self, ex=None,):
3064 chandransh 14159 
    self.ex = ex
1627 ankur.sing 14160 
 
14161 
  def read(self, iprot):
14162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14164 
      return
14165 
    iprot.readStructBegin()
14166 
    while True:
14167 
      (fname, ftype, fid) = iprot.readFieldBegin()
14168 
      if ftype == TType.STOP:
14169 
        break
4910 phani.kuma 14170 
      if fid == 1:
14171 
        if ftype == TType.STRUCT:
14172 
          self.ex = TransactionServiceException()
14173 
          self.ex.read(iprot)
14174 
        else:
14175 
          iprot.skip(ftype)
14176 
      else:
14177 
        iprot.skip(ftype)
14178 
      iprot.readFieldEnd()
14179 
    iprot.readStructEnd()
14180 
 
14181 
  def write(self, oprot):
14182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14184 
      return
14185 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14186 
    if self.ex is not None:
14187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14188 
      self.ex.write(oprot)
14189 
      oprot.writeFieldEnd()
14190 
    oprot.writeFieldStop()
14191 
    oprot.writeStructEnd()
14192 
 
14193 
  def validate(self):
14194 
    return
14195 
 
14196 
 
14197 
  def __repr__(self):
14198 
    L = ['%s=%r' % (key, value)
14199 
      for key, value in self.__dict__.iteritems()]
14200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14201 
 
14202 
  def __eq__(self, other):
14203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14204 
 
14205 
  def __ne__(self, other):
14206 
    return not (self == other)
14207 
 
14208 
class getNonDeliveredOrdersbyCourier_args:
14209 
  """
14210 
  Attributes:
14211 
   - providerId
14212 
  """
14213 
 
14214 
  thrift_spec = (
14215 
    None, # 0
14216 
    (1, TType.I64, 'providerId', None, None, ), # 1
14217 
  )
14218 
 
14219 
  def __init__(self, providerId=None,):
14220 
    self.providerId = providerId
14221 
 
14222 
  def read(self, iprot):
14223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14225 
      return
14226 
    iprot.readStructBegin()
14227 
    while True:
14228 
      (fname, ftype, fid) = iprot.readFieldBegin()
14229 
      if ftype == TType.STOP:
14230 
        break
14231 
      if fid == 1:
14232 
        if ftype == TType.I64:
14233 
          self.providerId = iprot.readI64();
14234 
        else:
14235 
          iprot.skip(ftype)
14236 
      else:
14237 
        iprot.skip(ftype)
14238 
      iprot.readFieldEnd()
14239 
    iprot.readStructEnd()
14240 
 
14241 
  def write(self, oprot):
14242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14244 
      return
14245 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14246 
    if self.providerId is not None:
14247 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14248 
      oprot.writeI64(self.providerId)
14249 
      oprot.writeFieldEnd()
14250 
    oprot.writeFieldStop()
14251 
    oprot.writeStructEnd()
14252 
 
14253 
  def validate(self):
14254 
    return
14255 
 
14256 
 
14257 
  def __repr__(self):
14258 
    L = ['%s=%r' % (key, value)
14259 
      for key, value in self.__dict__.iteritems()]
14260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14261 
 
14262 
  def __eq__(self, other):
14263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14264 
 
14265 
  def __ne__(self, other):
14266 
    return not (self == other)
14267 
 
14268 
class getNonDeliveredOrdersbyCourier_result:
14269 
  """
14270 
  Attributes:
14271 
   - success
14272 
  """
14273 
 
14274 
  thrift_spec = (
14275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14276 
  )
14277 
 
14278 
  def __init__(self, success=None,):
14279 
    self.success = success
14280 
 
14281 
  def read(self, iprot):
14282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14284 
      return
14285 
    iprot.readStructBegin()
14286 
    while True:
14287 
      (fname, ftype, fid) = iprot.readFieldBegin()
14288 
      if ftype == TType.STOP:
14289 
        break
4581 phani.kuma 14290 
      if fid == 0:
14291 
        if ftype == TType.LIST:
14292 
          self.success = []
6000 mandeep.dh 14293 
          (_etype319, _size316) = iprot.readListBegin()
14294 
          for _i320 in xrange(_size316):
14295 
            _elem321 = Order()
14296 
            _elem321.read(iprot)
14297 
            self.success.append(_elem321)
4581 phani.kuma 14298 
          iprot.readListEnd()
14299 
        else:
14300 
          iprot.skip(ftype)
4910 phani.kuma 14301 
      else:
14302 
        iprot.skip(ftype)
14303 
      iprot.readFieldEnd()
14304 
    iprot.readStructEnd()
14305 
 
14306 
  def write(self, oprot):
14307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14309 
      return
14310 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14311 
    if self.success is not None:
14312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14314 
      for iter322 in self.success:
14315 
        iter322.write(oprot)
4910 phani.kuma 14316 
      oprot.writeListEnd()
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
14335 
 
14336 
class markOrdersAsLocalConnected_args:
14337 
  """
14338 
  Attributes:
14339 
   - providerId
14340 
   - local_connected_orders
14341 
  """
14342 
 
14343 
  thrift_spec = (
14344 
    None, # 0
14345 
    (1, TType.I64, 'providerId', None, None, ), # 1
14346 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14347 
  )
14348 
 
14349 
  def __init__(self, providerId=None, local_connected_orders=None,):
14350 
    self.providerId = providerId
14351 
    self.local_connected_orders = local_connected_orders
14352 
 
14353 
  def read(self, iprot):
14354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14356 
      return
14357 
    iprot.readStructBegin()
14358 
    while True:
14359 
      (fname, ftype, fid) = iprot.readFieldBegin()
14360 
      if ftype == TType.STOP:
14361 
        break
14362 
      if fid == 1:
14363 
        if ftype == TType.I64:
14364 
          self.providerId = iprot.readI64();
14365 
        else:
14366 
          iprot.skip(ftype)
14367 
      elif fid == 2:
14368 
        if ftype == TType.MAP:
14369 
          self.local_connected_orders = {}
6000 mandeep.dh 14370 
          (_ktype324, _vtype325, _size323 ) = iprot.readMapBegin()
14371 
          for _i327 in xrange(_size323):
14372 
            _key328 = iprot.readString();
14373 
            _val329 = iprot.readString();
14374 
            self.local_connected_orders[_key328] = _val329
4910 phani.kuma 14375 
          iprot.readMapEnd()
14376 
        else:
14377 
          iprot.skip(ftype)
14378 
      else:
14379 
        iprot.skip(ftype)
14380 
      iprot.readFieldEnd()
14381 
    iprot.readStructEnd()
14382 
 
14383 
  def write(self, oprot):
14384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14386 
      return
14387 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14388 
    if self.providerId is not None:
14389 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14390 
      oprot.writeI64(self.providerId)
14391 
      oprot.writeFieldEnd()
14392 
    if self.local_connected_orders is not None:
14393 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14394 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6000 mandeep.dh 14395 
      for kiter330,viter331 in self.local_connected_orders.items():
14396 
        oprot.writeString(kiter330)
14397 
        oprot.writeString(viter331)
4910 phani.kuma 14398 
      oprot.writeMapEnd()
14399 
      oprot.writeFieldEnd()
14400 
    oprot.writeFieldStop()
14401 
    oprot.writeStructEnd()
14402 
 
14403 
  def validate(self):
14404 
    return
14405 
 
14406 
 
14407 
  def __repr__(self):
14408 
    L = ['%s=%r' % (key, value)
14409 
      for key, value in self.__dict__.iteritems()]
14410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14411 
 
14412 
  def __eq__(self, other):
14413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14414 
 
14415 
  def __ne__(self, other):
14416 
    return not (self == other)
14417 
 
14418 
class markOrdersAsLocalConnected_result:
14419 
  """
14420 
  Attributes:
14421 
   - ex
14422 
  """
14423 
 
14424 
  thrift_spec = (
14425 
    None, # 0
14426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14427 
  )
14428 
 
14429 
  def __init__(self, ex=None,):
14430 
    self.ex = ex
14431 
 
14432 
  def read(self, iprot):
14433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14435 
      return
14436 
    iprot.readStructBegin()
14437 
    while True:
14438 
      (fname, ftype, fid) = iprot.readFieldBegin()
14439 
      if ftype == TType.STOP:
14440 
        break
14441 
      if fid == 1:
3064 chandransh 14442 
        if ftype == TType.STRUCT:
14443 
          self.ex = TransactionServiceException()
14444 
          self.ex.read(iprot)
1627 ankur.sing 14445 
        else:
14446 
          iprot.skip(ftype)
14447 
      else:
14448 
        iprot.skip(ftype)
14449 
      iprot.readFieldEnd()
14450 
    iprot.readStructEnd()
14451 
 
14452 
  def write(self, oprot):
14453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14455 
      return
4910 phani.kuma 14456 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14457 
    if self.ex is not None:
14458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14459 
      self.ex.write(oprot)
14460 
      oprot.writeFieldEnd()
14461 
    oprot.writeFieldStop()
14462 
    oprot.writeStructEnd()
14463 
 
14464 
  def validate(self):
14465 
    return
14466 
 
14467 
 
14468 
  def __repr__(self):
14469 
    L = ['%s=%r' % (key, value)
14470 
      for key, value in self.__dict__.iteritems()]
14471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14472 
 
14473 
  def __eq__(self, other):
14474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14475 
 
14476 
  def __ne__(self, other):
14477 
    return not (self == other)
14478 
 
14479 
class getOrdersNotLocalConnected_args:
14480 
  """
14481 
  Attributes:
14482 
   - providerId
14483 
  """
14484 
 
14485 
  thrift_spec = (
14486 
    None, # 0
14487 
    (1, TType.I64, 'providerId', None, None, ), # 1
14488 
  )
14489 
 
14490 
  def __init__(self, providerId=None,):
14491 
    self.providerId = providerId
14492 
 
14493 
  def read(self, iprot):
14494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14496 
      return
14497 
    iprot.readStructBegin()
14498 
    while True:
14499 
      (fname, ftype, fid) = iprot.readFieldBegin()
14500 
      if ftype == TType.STOP:
14501 
        break
14502 
      if fid == 1:
14503 
        if ftype == TType.I64:
14504 
          self.providerId = iprot.readI64();
14505 
        else:
14506 
          iprot.skip(ftype)
14507 
      else:
14508 
        iprot.skip(ftype)
14509 
      iprot.readFieldEnd()
14510 
    iprot.readStructEnd()
14511 
 
14512 
  def write(self, oprot):
14513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14515 
      return
14516 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14517 
    if self.providerId is not None:
14518 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14519 
      oprot.writeI64(self.providerId)
14520 
      oprot.writeFieldEnd()
14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
14539 
class getOrdersNotLocalConnected_result:
14540 
  """
14541 
  Attributes:
14542 
   - success
14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14547 
  )
14548 
 
14549 
  def __init__(self, success=None,):
14550 
    self.success = success
14551 
 
14552 
  def read(self, iprot):
14553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14555 
      return
14556 
    iprot.readStructBegin()
14557 
    while True:
14558 
      (fname, ftype, fid) = iprot.readFieldBegin()
14559 
      if ftype == TType.STOP:
14560 
        break
14561 
      if fid == 0:
14562 
        if ftype == TType.LIST:
14563 
          self.success = []
6000 mandeep.dh 14564 
          (_etype335, _size332) = iprot.readListBegin()
14565 
          for _i336 in xrange(_size332):
14566 
            _elem337 = Order()
14567 
            _elem337.read(iprot)
14568 
            self.success.append(_elem337)
4910 phani.kuma 14569 
          iprot.readListEnd()
14570 
        else:
14571 
          iprot.skip(ftype)
14572 
      else:
14573 
        iprot.skip(ftype)
14574 
      iprot.readFieldEnd()
14575 
    iprot.readStructEnd()
14576 
 
14577 
  def write(self, oprot):
14578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14580 
      return
14581 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14582 
    if self.success is not None:
14583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14585 
      for iter338 in self.success:
14586 
        iter338.write(oprot)
4581 phani.kuma 14587 
      oprot.writeListEnd()
14588 
      oprot.writeFieldEnd()
4910 phani.kuma 14589 
    oprot.writeFieldStop()
14590 
    oprot.writeStructEnd()
14591 
 
14592 
  def validate(self):
14593 
    return
14594 
 
14595 
 
14596 
  def __repr__(self):
14597 
    L = ['%s=%r' % (key, value)
14598 
      for key, value in self.__dict__.iteritems()]
14599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14600 
 
14601 
  def __eq__(self, other):
14602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14603 
 
14604 
  def __ne__(self, other):
14605 
    return not (self == other)
14606 
 
14607 
class markOrdersAsDestinationCityReached_args:
14608 
  """
14609 
  Attributes:
14610 
   - providerId
14611 
   - destination_city_reached_orders
14612 
  """
14613 
 
14614 
  thrift_spec = (
14615 
    None, # 0
14616 
    (1, TType.I64, 'providerId', None, None, ), # 1
14617 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14618 
  )
14619 
 
14620 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14621 
    self.providerId = providerId
14622 
    self.destination_city_reached_orders = destination_city_reached_orders
14623 
 
14624 
  def read(self, iprot):
14625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14627 
      return
14628 
    iprot.readStructBegin()
14629 
    while True:
14630 
      (fname, ftype, fid) = iprot.readFieldBegin()
14631 
      if ftype == TType.STOP:
14632 
        break
14633 
      if fid == 1:
14634 
        if ftype == TType.I64:
14635 
          self.providerId = iprot.readI64();
14636 
        else:
14637 
          iprot.skip(ftype)
14638 
      elif fid == 2:
14639 
        if ftype == TType.MAP:
14640 
          self.destination_city_reached_orders = {}
6000 mandeep.dh 14641 
          (_ktype340, _vtype341, _size339 ) = iprot.readMapBegin()
14642 
          for _i343 in xrange(_size339):
14643 
            _key344 = iprot.readString();
14644 
            _val345 = iprot.readString();
14645 
            self.destination_city_reached_orders[_key344] = _val345
4910 phani.kuma 14646 
          iprot.readMapEnd()
14647 
        else:
14648 
          iprot.skip(ftype)
14649 
      else:
14650 
        iprot.skip(ftype)
14651 
      iprot.readFieldEnd()
14652 
    iprot.readStructEnd()
14653 
 
14654 
  def write(self, oprot):
14655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14657 
      return
14658 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14659 
    if self.providerId is not None:
14660 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14661 
      oprot.writeI64(self.providerId)
14662 
      oprot.writeFieldEnd()
14663 
    if self.destination_city_reached_orders is not None:
14664 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6000 mandeep.dh 14666 
      for kiter346,viter347 in self.destination_city_reached_orders.items():
14667 
        oprot.writeString(kiter346)
14668 
        oprot.writeString(viter347)
4910 phani.kuma 14669 
      oprot.writeMapEnd()
14670 
      oprot.writeFieldEnd()
14671 
    oprot.writeFieldStop()
14672 
    oprot.writeStructEnd()
14673 
 
14674 
  def validate(self):
14675 
    return
14676 
 
14677 
 
14678 
  def __repr__(self):
14679 
    L = ['%s=%r' % (key, value)
14680 
      for key, value in self.__dict__.iteritems()]
14681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14682 
 
14683 
  def __eq__(self, other):
14684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14685 
 
14686 
  def __ne__(self, other):
14687 
    return not (self == other)
14688 
 
14689 
class markOrdersAsDestinationCityReached_result:
14690 
  """
14691 
  Attributes:
14692 
   - ex
14693 
  """
14694 
 
14695 
  thrift_spec = (
14696 
    None, # 0
14697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14698 
  )
14699 
 
14700 
  def __init__(self, ex=None,):
14701 
    self.ex = ex
14702 
 
14703 
  def read(self, iprot):
14704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14706 
      return
14707 
    iprot.readStructBegin()
14708 
    while True:
14709 
      (fname, ftype, fid) = iprot.readFieldBegin()
14710 
      if ftype == TType.STOP:
14711 
        break
14712 
      if fid == 1:
14713 
        if ftype == TType.STRUCT:
14714 
          self.ex = TransactionServiceException()
14715 
          self.ex.read(iprot)
14716 
        else:
14717 
          iprot.skip(ftype)
14718 
      else:
14719 
        iprot.skip(ftype)
14720 
      iprot.readFieldEnd()
14721 
    iprot.readStructEnd()
14722 
 
14723 
  def write(self, oprot):
14724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14726 
      return
14727 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14728 
    if self.ex is not None:
3064 chandransh 14729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14730 
      self.ex.write(oprot)
1627 ankur.sing 14731 
      oprot.writeFieldEnd()
14732 
    oprot.writeFieldStop()
14733 
    oprot.writeStructEnd()
14734 
 
3431 rajveer 14735 
  def validate(self):
14736 
    return
14737 
 
14738 
 
1627 ankur.sing 14739 
  def __repr__(self):
14740 
    L = ['%s=%r' % (key, value)
14741 
      for key, value in self.__dict__.iteritems()]
14742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14743 
 
14744 
  def __eq__(self, other):
14745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14746 
 
14747 
  def __ne__(self, other):
14748 
    return not (self == other)
14749 
 
4910 phani.kuma 14750 
class markOrdersAsFirstDeliveryAttempted_args:
14751 
  """
14752 
  Attributes:
14753 
   - providerId
14754 
   - first_atdl_orders
14755 
  """
14756 
 
14757 
  thrift_spec = (
14758 
    None, # 0
14759 
    (1, TType.I64, 'providerId', None, None, ), # 1
14760 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14761 
  )
14762 
 
14763 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14764 
    self.providerId = providerId
14765 
    self.first_atdl_orders = first_atdl_orders
14766 
 
14767 
  def read(self, iprot):
14768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14770 
      return
14771 
    iprot.readStructBegin()
14772 
    while True:
14773 
      (fname, ftype, fid) = iprot.readFieldBegin()
14774 
      if ftype == TType.STOP:
14775 
        break
14776 
      if fid == 1:
14777 
        if ftype == TType.I64:
14778 
          self.providerId = iprot.readI64();
14779 
        else:
14780 
          iprot.skip(ftype)
14781 
      elif fid == 2:
14782 
        if ftype == TType.MAP:
14783 
          self.first_atdl_orders = {}
6000 mandeep.dh 14784 
          (_ktype349, _vtype350, _size348 ) = iprot.readMapBegin()
14785 
          for _i352 in xrange(_size348):
14786 
            _key353 = iprot.readString();
14787 
            _val354 = iprot.readString();
14788 
            self.first_atdl_orders[_key353] = _val354
4910 phani.kuma 14789 
          iprot.readMapEnd()
14790 
        else:
14791 
          iprot.skip(ftype)
14792 
      else:
14793 
        iprot.skip(ftype)
14794 
      iprot.readFieldEnd()
14795 
    iprot.readStructEnd()
14796 
 
14797 
  def write(self, oprot):
14798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14800 
      return
14801 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14802 
    if self.providerId is not None:
14803 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14804 
      oprot.writeI64(self.providerId)
14805 
      oprot.writeFieldEnd()
14806 
    if self.first_atdl_orders is not None:
14807 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14808 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6000 mandeep.dh 14809 
      for kiter355,viter356 in self.first_atdl_orders.items():
14810 
        oprot.writeString(kiter355)
14811 
        oprot.writeString(viter356)
4910 phani.kuma 14812 
      oprot.writeMapEnd()
14813 
      oprot.writeFieldEnd()
14814 
    oprot.writeFieldStop()
14815 
    oprot.writeStructEnd()
14816 
 
14817 
  def validate(self):
14818 
    return
14819 
 
14820 
 
14821 
  def __repr__(self):
14822 
    L = ['%s=%r' % (key, value)
14823 
      for key, value in self.__dict__.iteritems()]
14824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14825 
 
14826 
  def __eq__(self, other):
14827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14828 
 
14829 
  def __ne__(self, other):
14830 
    return not (self == other)
14831 
 
14832 
class markOrdersAsFirstDeliveryAttempted_result:
14833 
  """
14834 
  Attributes:
14835 
   - ex
14836 
  """
14837 
 
14838 
  thrift_spec = (
14839 
    None, # 0
14840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14841 
  )
14842 
 
14843 
  def __init__(self, ex=None,):
14844 
    self.ex = ex
14845 
 
14846 
  def read(self, iprot):
14847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14849 
      return
14850 
    iprot.readStructBegin()
14851 
    while True:
14852 
      (fname, ftype, fid) = iprot.readFieldBegin()
14853 
      if ftype == TType.STOP:
14854 
        break
14855 
      if fid == 1:
14856 
        if ftype == TType.STRUCT:
14857 
          self.ex = TransactionServiceException()
14858 
          self.ex.read(iprot)
14859 
        else:
14860 
          iprot.skip(ftype)
14861 
      else:
14862 
        iprot.skip(ftype)
14863 
      iprot.readFieldEnd()
14864 
    iprot.readStructEnd()
14865 
 
14866 
  def write(self, oprot):
14867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14869 
      return
14870 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14871 
    if self.ex is not None:
14872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14873 
      self.ex.write(oprot)
14874 
      oprot.writeFieldEnd()
14875 
    oprot.writeFieldStop()
14876 
    oprot.writeStructEnd()
14877 
 
14878 
  def validate(self):
14879 
    return
14880 
 
14881 
 
14882 
  def __repr__(self):
14883 
    L = ['%s=%r' % (key, value)
14884 
      for key, value in self.__dict__.iteritems()]
14885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14886 
 
14887 
  def __eq__(self, other):
14888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14889 
 
14890 
  def __ne__(self, other):
14891 
    return not (self == other)
14892 
 
3064 chandransh 14893 
class getUndeliveredOrders_args:
1886 ankur.sing 14894 
  """
14895 
  Attributes:
3064 chandransh 14896 
   - providerId
14897 
   - warehouseId
1886 ankur.sing 14898 
  """
1627 ankur.sing 14899 
 
1886 ankur.sing 14900 
  thrift_spec = (
14901 
    None, # 0
3064 chandransh 14902 
    (1, TType.I64, 'providerId', None, None, ), # 1
14903 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14904 
  )
14905 
 
3064 chandransh 14906 
  def __init__(self, providerId=None, warehouseId=None,):
14907 
    self.providerId = providerId
14908 
    self.warehouseId = warehouseId
1886 ankur.sing 14909 
 
14910 
  def read(self, iprot):
14911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14913 
      return
14914 
    iprot.readStructBegin()
14915 
    while True:
14916 
      (fname, ftype, fid) = iprot.readFieldBegin()
14917 
      if ftype == TType.STOP:
14918 
        break
14919 
      if fid == 1:
14920 
        if ftype == TType.I64:
3064 chandransh 14921 
          self.providerId = iprot.readI64();
1886 ankur.sing 14922 
        else:
14923 
          iprot.skip(ftype)
3064 chandransh 14924 
      elif fid == 2:
14925 
        if ftype == TType.I64:
14926 
          self.warehouseId = iprot.readI64();
14927 
        else:
14928 
          iprot.skip(ftype)
1886 ankur.sing 14929 
      else:
14930 
        iprot.skip(ftype)
14931 
      iprot.readFieldEnd()
14932 
    iprot.readStructEnd()
14933 
 
14934 
  def write(self, oprot):
14935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14937 
      return
3064 chandransh 14938 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14939 
    if self.providerId is not None:
3064 chandransh 14940 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14941 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14942 
      oprot.writeFieldEnd()
3431 rajveer 14943 
    if self.warehouseId is not None:
3064 chandransh 14944 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14945 
      oprot.writeI64(self.warehouseId)
14946 
      oprot.writeFieldEnd()
1886 ankur.sing 14947 
    oprot.writeFieldStop()
14948 
    oprot.writeStructEnd()
14949 
 
3431 rajveer 14950 
  def validate(self):
14951 
    return
14952 
 
14953 
 
1886 ankur.sing 14954 
  def __repr__(self):
14955 
    L = ['%s=%r' % (key, value)
14956 
      for key, value in self.__dict__.iteritems()]
14957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14958 
 
14959 
  def __eq__(self, other):
14960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14961 
 
14962 
  def __ne__(self, other):
14963 
    return not (self == other)
14964 
 
3064 chandransh 14965 
class getUndeliveredOrders_result:
1886 ankur.sing 14966 
  """
14967 
  Attributes:
14968 
   - success
14969 
  """
14970 
 
14971 
  thrift_spec = (
14972 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14973 
  )
14974 
 
14975 
  def __init__(self, success=None,):
14976 
    self.success = success
14977 
 
14978 
  def read(self, iprot):
14979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14981 
      return
14982 
    iprot.readStructBegin()
14983 
    while True:
14984 
      (fname, ftype, fid) = iprot.readFieldBegin()
14985 
      if ftype == TType.STOP:
14986 
        break
14987 
      if fid == 0:
14988 
        if ftype == TType.LIST:
14989 
          self.success = []
6000 mandeep.dh 14990 
          (_etype360, _size357) = iprot.readListBegin()
14991 
          for _i361 in xrange(_size357):
14992 
            _elem362 = Order()
14993 
            _elem362.read(iprot)
14994 
            self.success.append(_elem362)
1886 ankur.sing 14995 
          iprot.readListEnd()
14996 
        else:
14997 
          iprot.skip(ftype)
14998 
      else:
14999 
        iprot.skip(ftype)
15000 
      iprot.readFieldEnd()
15001 
    iprot.readStructEnd()
15002 
 
15003 
  def write(self, oprot):
15004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15006 
      return
3064 chandransh 15007 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15008 
    if self.success is not None:
1886 ankur.sing 15009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15010 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 15011 
      for iter363 in self.success:
15012 
        iter363.write(oprot)
1886 ankur.sing 15013 
      oprot.writeListEnd()
15014 
      oprot.writeFieldEnd()
15015 
    oprot.writeFieldStop()
15016 
    oprot.writeStructEnd()
15017 
 
3431 rajveer 15018 
  def validate(self):
15019 
    return
15020 
 
15021 
 
1886 ankur.sing 15022 
  def __repr__(self):
15023 
    L = ['%s=%r' % (key, value)
15024 
      for key, value in self.__dict__.iteritems()]
15025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15026 
 
15027 
  def __eq__(self, other):
15028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15029 
 
15030 
  def __ne__(self, other):
15031 
    return not (self == other)
15032 
 
4783 phani.kuma 15033 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15034 
 
15035 
  thrift_spec = (
15036 
  )
15037 
 
15038 
  def read(self, iprot):
15039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15041 
      return
15042 
    iprot.readStructBegin()
15043 
    while True:
15044 
      (fname, ftype, fid) = iprot.readFieldBegin()
15045 
      if ftype == TType.STOP:
15046 
        break
15047 
      else:
15048 
        iprot.skip(ftype)
15049 
      iprot.readFieldEnd()
15050 
    iprot.readStructEnd()
15051 
 
15052 
  def write(self, oprot):
15053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15055 
      return
15056 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15057 
    oprot.writeFieldStop()
15058 
    oprot.writeStructEnd()
15059 
 
15060 
  def validate(self):
15061 
    return
15062 
 
15063 
 
15064 
  def __repr__(self):
15065 
    L = ['%s=%r' % (key, value)
15066 
      for key, value in self.__dict__.iteritems()]
15067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15068 
 
15069 
  def __eq__(self, other):
15070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15071 
 
15072 
  def __ne__(self, other):
15073 
    return not (self == other)
15074 
 
15075 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15076 
  """
15077 
  Attributes:
15078 
   - success
15079 
  """
15080 
 
15081 
  thrift_spec = (
15082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15083 
  )
15084 
 
15085 
  def __init__(self, success=None,):
15086 
    self.success = success
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 == 0:
15098 
        if ftype == TType.LIST:
15099 
          self.success = []
6000 mandeep.dh 15100 
          (_etype367, _size364) = iprot.readListBegin()
15101 
          for _i368 in xrange(_size364):
15102 
            _elem369 = Order()
15103 
            _elem369.read(iprot)
15104 
            self.success.append(_elem369)
4783 phani.kuma 15105 
          iprot.readListEnd()
15106 
        else:
15107 
          iprot.skip(ftype)
15108 
      else:
15109 
        iprot.skip(ftype)
15110 
      iprot.readFieldEnd()
15111 
    iprot.readStructEnd()
15112 
 
15113 
  def write(self, oprot):
15114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15116 
      return
15117 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15118 
    if self.success is not None:
15119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 15121 
      for iter370 in self.success:
15122 
        iter370.write(oprot)
4783 phani.kuma 15123 
      oprot.writeListEnd()
15124 
      oprot.writeFieldEnd()
15125 
    oprot.writeFieldStop()
15126 
    oprot.writeStructEnd()
15127 
 
15128 
  def validate(self):
15129 
    return
15130 
 
15131 
 
15132 
  def __repr__(self):
15133 
    L = ['%s=%r' % (key, value)
15134 
      for key, value in self.__dict__.iteritems()]
15135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15136 
 
15137 
  def __eq__(self, other):
15138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15139 
 
15140 
  def __ne__(self, other):
15141 
    return not (self == other)
15142 
 
2536 chandransh 15143 
class toggleDOAFlag_args:
15144 
  """
15145 
  Attributes:
15146 
   - orderId
15147 
  """
1886 ankur.sing 15148 
 
2536 chandransh 15149 
  thrift_spec = (
15150 
    None, # 0
15151 
    (1, TType.I64, 'orderId', None, None, ), # 1
15152 
  )
15153 
 
15154 
  def __init__(self, orderId=None,):
15155 
    self.orderId = orderId
15156 
 
15157 
  def read(self, iprot):
15158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15160 
      return
15161 
    iprot.readStructBegin()
15162 
    while True:
15163 
      (fname, ftype, fid) = iprot.readFieldBegin()
15164 
      if ftype == TType.STOP:
15165 
        break
15166 
      if fid == 1:
15167 
        if ftype == TType.I64:
15168 
          self.orderId = iprot.readI64();
15169 
        else:
15170 
          iprot.skip(ftype)
15171 
      else:
15172 
        iprot.skip(ftype)
15173 
      iprot.readFieldEnd()
15174 
    iprot.readStructEnd()
15175 
 
15176 
  def write(self, oprot):
15177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15179 
      return
15180 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15181 
    if self.orderId is not None:
2536 chandransh 15182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15183 
      oprot.writeI64(self.orderId)
15184 
      oprot.writeFieldEnd()
15185 
    oprot.writeFieldStop()
15186 
    oprot.writeStructEnd()
15187 
 
3431 rajveer 15188 
  def validate(self):
15189 
    return
15190 
 
15191 
 
2536 chandransh 15192 
  def __repr__(self):
15193 
    L = ['%s=%r' % (key, value)
15194 
      for key, value in self.__dict__.iteritems()]
15195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15196 
 
15197 
  def __eq__(self, other):
15198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15199 
 
15200 
  def __ne__(self, other):
15201 
    return not (self == other)
15202 
 
15203 
class toggleDOAFlag_result:
15204 
  """
15205 
  Attributes:
15206 
   - success
15207 
   - ex
15208 
  """
15209 
 
15210 
  thrift_spec = (
15211 
    (0, TType.BOOL, 'success', None, None, ), # 0
15212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15213 
  )
15214 
 
15215 
  def __init__(self, success=None, ex=None,):
15216 
    self.success = success
15217 
    self.ex = ex
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 0:
15229 
        if ftype == TType.BOOL:
15230 
          self.success = iprot.readBool();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      elif fid == 1:
15234 
        if ftype == TType.STRUCT:
15235 
          self.ex = TransactionServiceException()
15236 
          self.ex.read(iprot)
15237 
        else:
15238 
          iprot.skip(ftype)
15239 
      else:
15240 
        iprot.skip(ftype)
15241 
      iprot.readFieldEnd()
15242 
    iprot.readStructEnd()
15243 
 
15244 
  def write(self, oprot):
15245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15247 
      return
15248 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15249 
    if self.success is not None:
2536 chandransh 15250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15251 
      oprot.writeBool(self.success)
15252 
      oprot.writeFieldEnd()
3431 rajveer 15253 
    if self.ex is not None:
2536 chandransh 15254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15255 
      self.ex.write(oprot)
15256 
      oprot.writeFieldEnd()
15257 
    oprot.writeFieldStop()
15258 
    oprot.writeStructEnd()
15259 
 
3431 rajveer 15260 
  def validate(self):
15261 
    return
15262 
 
15263 
 
2536 chandransh 15264 
  def __repr__(self):
15265 
    L = ['%s=%r' % (key, value)
15266 
      for key, value in self.__dict__.iteritems()]
15267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15268 
 
15269 
  def __eq__(self, other):
15270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15271 
 
15272 
  def __ne__(self, other):
15273 
    return not (self == other)
15274 
 
4712 rajveer 15275 
class markOrderAsDelivered_args:
15276 
  """
15277 
  Attributes:
15278 
   - orderId
15279 
   - deliveryTimestamp
15280 
   - receiver
15281 
  """
15282 
 
15283 
  thrift_spec = None
15284 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15285 
    self.orderId = orderId
15286 
    self.deliveryTimestamp = deliveryTimestamp
15287 
    self.receiver = receiver
15288 
 
15289 
  def read(self, iprot):
15290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15292 
      return
15293 
    iprot.readStructBegin()
15294 
    while True:
15295 
      (fname, ftype, fid) = iprot.readFieldBegin()
15296 
      if ftype == TType.STOP:
15297 
        break
15298 
      if fid == 1:
15299 
        if ftype == TType.I64:
15300 
          self.orderId = iprot.readI64();
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      elif fid == 2:
15304 
        if ftype == TType.I64:
15305 
          self.deliveryTimestamp = iprot.readI64();
15306 
        else:
15307 
          iprot.skip(ftype)
15308 
      elif fid == -1:
15309 
        if ftype == TType.STRING:
15310 
          self.receiver = iprot.readString();
15311 
        else:
15312 
          iprot.skip(ftype)
15313 
      else:
15314 
        iprot.skip(ftype)
15315 
      iprot.readFieldEnd()
15316 
    iprot.readStructEnd()
15317 
 
15318 
  def write(self, oprot):
15319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15321 
      return
15322 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15323 
    if self.receiver is not None:
15324 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15325 
      oprot.writeString(self.receiver)
15326 
      oprot.writeFieldEnd()
15327 
    if self.orderId is not None:
15328 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15329 
      oprot.writeI64(self.orderId)
15330 
      oprot.writeFieldEnd()
15331 
    if self.deliveryTimestamp is not None:
15332 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15333 
      oprot.writeI64(self.deliveryTimestamp)
15334 
      oprot.writeFieldEnd()
15335 
    oprot.writeFieldStop()
15336 
    oprot.writeStructEnd()
15337 
 
15338 
  def validate(self):
15339 
    return
15340 
 
15341 
 
15342 
  def __repr__(self):
15343 
    L = ['%s=%r' % (key, value)
15344 
      for key, value in self.__dict__.iteritems()]
15345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15346 
 
15347 
  def __eq__(self, other):
15348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15349 
 
15350 
  def __ne__(self, other):
15351 
    return not (self == other)
15352 
 
15353 
class markOrderAsDelivered_result:
15354 
  """
15355 
  Attributes:
15356 
   - ex
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    None, # 0
15361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15362 
  )
15363 
 
15364 
  def __init__(self, ex=None,):
15365 
    self.ex = ex
15366 
 
15367 
  def read(self, iprot):
15368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15370 
      return
15371 
    iprot.readStructBegin()
15372 
    while True:
15373 
      (fname, ftype, fid) = iprot.readFieldBegin()
15374 
      if ftype == TType.STOP:
15375 
        break
15376 
      if fid == 1:
15377 
        if ftype == TType.STRUCT:
15378 
          self.ex = TransactionServiceException()
15379 
          self.ex.read(iprot)
15380 
        else:
15381 
          iprot.skip(ftype)
15382 
      else:
15383 
        iprot.skip(ftype)
15384 
      iprot.readFieldEnd()
15385 
    iprot.readStructEnd()
15386 
 
15387 
  def write(self, oprot):
15388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15390 
      return
15391 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15392 
    if self.ex is not None:
15393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15394 
      self.ex.write(oprot)
15395 
      oprot.writeFieldEnd()
15396 
    oprot.writeFieldStop()
15397 
    oprot.writeStructEnd()
15398 
 
15399 
  def validate(self):
15400 
    return
15401 
 
15402 
 
15403 
  def __repr__(self):
15404 
    L = ['%s=%r' % (key, value)
15405 
      for key, value in self.__dict__.iteritems()]
15406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15407 
 
15408 
  def __eq__(self, other):
15409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15410 
 
15411 
  def __ne__(self, other):
15412 
    return not (self == other)
15413 
 
5553 rajveer 15414 
class markOrderAsReceivedAtStore_args:
15415 
  """
15416 
  Attributes:
15417 
   - orderId
15418 
   - deliveryTimestamp
15419 
  """
15420 
 
15421 
  thrift_spec = (
15422 
    None, # 0
15423 
    (1, TType.I64, 'orderId', None, None, ), # 1
15424 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15425 
  )
15426 
 
15427 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15428 
    self.orderId = orderId
15429 
    self.deliveryTimestamp = deliveryTimestamp
15430 
 
15431 
  def read(self, iprot):
15432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15434 
      return
15435 
    iprot.readStructBegin()
15436 
    while True:
15437 
      (fname, ftype, fid) = iprot.readFieldBegin()
15438 
      if ftype == TType.STOP:
15439 
        break
15440 
      if fid == 1:
15441 
        if ftype == TType.I64:
15442 
          self.orderId = iprot.readI64();
15443 
        else:
15444 
          iprot.skip(ftype)
15445 
      elif fid == 2:
15446 
        if ftype == TType.I64:
15447 
          self.deliveryTimestamp = iprot.readI64();
15448 
        else:
15449 
          iprot.skip(ftype)
15450 
      else:
15451 
        iprot.skip(ftype)
15452 
      iprot.readFieldEnd()
15453 
    iprot.readStructEnd()
15454 
 
15455 
  def write(self, oprot):
15456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15458 
      return
15459 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15460 
    if self.orderId is not None:
15461 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15462 
      oprot.writeI64(self.orderId)
15463 
      oprot.writeFieldEnd()
15464 
    if self.deliveryTimestamp is not None:
15465 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15466 
      oprot.writeI64(self.deliveryTimestamp)
15467 
      oprot.writeFieldEnd()
15468 
    oprot.writeFieldStop()
15469 
    oprot.writeStructEnd()
15470 
 
15471 
  def validate(self):
15472 
    return
15473 
 
15474 
 
15475 
  def __repr__(self):
15476 
    L = ['%s=%r' % (key, value)
15477 
      for key, value in self.__dict__.iteritems()]
15478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15479 
 
15480 
  def __eq__(self, other):
15481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15482 
 
15483 
  def __ne__(self, other):
15484 
    return not (self == other)
15485 
 
15486 
class markOrderAsReceivedAtStore_result:
15487 
  """
15488 
  Attributes:
15489 
   - ex
15490 
  """
15491 
 
15492 
  thrift_spec = (
15493 
    None, # 0
15494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15495 
  )
15496 
 
15497 
  def __init__(self, ex=None,):
15498 
    self.ex = ex
15499 
 
15500 
  def read(self, iprot):
15501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15503 
      return
15504 
    iprot.readStructBegin()
15505 
    while True:
15506 
      (fname, ftype, fid) = iprot.readFieldBegin()
15507 
      if ftype == TType.STOP:
15508 
        break
15509 
      if fid == 1:
15510 
        if ftype == TType.STRUCT:
15511 
          self.ex = TransactionServiceException()
15512 
          self.ex.read(iprot)
15513 
        else:
15514 
          iprot.skip(ftype)
15515 
      else:
15516 
        iprot.skip(ftype)
15517 
      iprot.readFieldEnd()
15518 
    iprot.readStructEnd()
15519 
 
15520 
  def write(self, oprot):
15521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15523 
      return
15524 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15525 
    if self.ex is not None:
15526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15527 
      self.ex.write(oprot)
15528 
      oprot.writeFieldEnd()
15529 
    oprot.writeFieldStop()
15530 
    oprot.writeStructEnd()
15531 
 
15532 
  def validate(self):
15533 
    return
15534 
 
15535 
 
15536 
  def __repr__(self):
15537 
    L = ['%s=%r' % (key, value)
15538 
      for key, value in self.__dict__.iteritems()]
15539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15540 
 
15541 
  def __eq__(self, other):
15542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15543 
 
15544 
  def __ne__(self, other):
15545 
    return not (self == other)
15546 
 
4454 rajveer 15547 
class markOrderDoaRequestReceived_args:
15548 
  """
15549 
  Attributes:
15550 
   - orderId
15551 
  """
15552 
 
15553 
  thrift_spec = (
15554 
    None, # 0
15555 
    (1, TType.I64, 'orderId', None, None, ), # 1
15556 
  )
15557 
 
15558 
  def __init__(self, orderId=None,):
15559 
    self.orderId = orderId
15560 
 
15561 
  def read(self, iprot):
15562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15564 
      return
15565 
    iprot.readStructBegin()
15566 
    while True:
15567 
      (fname, ftype, fid) = iprot.readFieldBegin()
15568 
      if ftype == TType.STOP:
15569 
        break
15570 
      if fid == 1:
15571 
        if ftype == TType.I64:
15572 
          self.orderId = iprot.readI64();
15573 
        else:
15574 
          iprot.skip(ftype)
15575 
      else:
15576 
        iprot.skip(ftype)
15577 
      iprot.readFieldEnd()
15578 
    iprot.readStructEnd()
15579 
 
15580 
  def write(self, oprot):
15581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15583 
      return
15584 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15585 
    if self.orderId is not None:
15586 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15587 
      oprot.writeI64(self.orderId)
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 
 
15607 
class markOrderDoaRequestReceived_result:
15608 
  """
15609 
  Attributes:
15610 
   - success
15611 
   - ex
15612 
  """
15613 
 
15614 
  thrift_spec = (
15615 
    (0, TType.BOOL, 'success', None, None, ), # 0
15616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15617 
  )
15618 
 
15619 
  def __init__(self, success=None, ex=None,):
15620 
    self.success = success
15621 
    self.ex = ex
15622 
 
15623 
  def read(self, iprot):
15624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15626 
      return
15627 
    iprot.readStructBegin()
15628 
    while True:
15629 
      (fname, ftype, fid) = iprot.readFieldBegin()
15630 
      if ftype == TType.STOP:
15631 
        break
15632 
      if fid == 0:
15633 
        if ftype == TType.BOOL:
15634 
          self.success = iprot.readBool();
15635 
        else:
15636 
          iprot.skip(ftype)
15637 
      elif fid == 1:
15638 
        if ftype == TType.STRUCT:
15639 
          self.ex = TransactionServiceException()
15640 
          self.ex.read(iprot)
15641 
        else:
15642 
          iprot.skip(ftype)
15643 
      else:
15644 
        iprot.skip(ftype)
15645 
      iprot.readFieldEnd()
15646 
    iprot.readStructEnd()
15647 
 
15648 
  def write(self, oprot):
15649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15651 
      return
15652 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15653 
    if self.success is not None:
15654 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15655 
      oprot.writeBool(self.success)
15656 
      oprot.writeFieldEnd()
15657 
    if self.ex is not None:
15658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15659 
      self.ex.write(oprot)
15660 
      oprot.writeFieldEnd()
15661 
    oprot.writeFieldStop()
15662 
    oprot.writeStructEnd()
15663 
 
15664 
  def validate(self):
15665 
    return
15666 
 
15667 
 
15668 
  def __repr__(self):
15669 
    L = ['%s=%r' % (key, value)
15670 
      for key, value in self.__dict__.iteritems()]
15671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15672 
 
15673 
  def __eq__(self, other):
15674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15675 
 
15676 
  def __ne__(self, other):
15677 
    return not (self == other)
15678 
 
15679 
class markOrderDoaRequestAuthorized_args:
15680 
  """
15681 
  Attributes:
15682 
   - orderId
15683 
   - isAuthorized
15684 
  """
15685 
 
15686 
  thrift_spec = (
15687 
    None, # 0
15688 
    (1, TType.I64, 'orderId', None, None, ), # 1
15689 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15690 
  )
15691 
 
15692 
  def __init__(self, orderId=None, isAuthorized=None,):
15693 
    self.orderId = orderId
15694 
    self.isAuthorized = isAuthorized
15695 
 
15696 
  def read(self, iprot):
15697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15699 
      return
15700 
    iprot.readStructBegin()
15701 
    while True:
15702 
      (fname, ftype, fid) = iprot.readFieldBegin()
15703 
      if ftype == TType.STOP:
15704 
        break
15705 
      if fid == 1:
15706 
        if ftype == TType.I64:
15707 
          self.orderId = iprot.readI64();
15708 
        else:
15709 
          iprot.skip(ftype)
15710 
      elif fid == 2:
15711 
        if ftype == TType.BOOL:
15712 
          self.isAuthorized = iprot.readBool();
15713 
        else:
15714 
          iprot.skip(ftype)
15715 
      else:
15716 
        iprot.skip(ftype)
15717 
      iprot.readFieldEnd()
15718 
    iprot.readStructEnd()
15719 
 
15720 
  def write(self, oprot):
15721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15723 
      return
15724 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15725 
    if self.orderId is not None:
15726 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15727 
      oprot.writeI64(self.orderId)
15728 
      oprot.writeFieldEnd()
15729 
    if self.isAuthorized is not None:
15730 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15731 
      oprot.writeBool(self.isAuthorized)
15732 
      oprot.writeFieldEnd()
15733 
    oprot.writeFieldStop()
15734 
    oprot.writeStructEnd()
15735 
 
15736 
  def validate(self):
15737 
    return
15738 
 
15739 
 
15740 
  def __repr__(self):
15741 
    L = ['%s=%r' % (key, value)
15742 
      for key, value in self.__dict__.iteritems()]
15743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15744 
 
15745 
  def __eq__(self, other):
15746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15747 
 
15748 
  def __ne__(self, other):
15749 
    return not (self == other)
15750 
 
15751 
class markOrderDoaRequestAuthorized_result:
15752 
  """
15753 
  Attributes:
15754 
   - success
15755 
   - ex
15756 
  """
15757 
 
15758 
  thrift_spec = (
15759 
    (0, TType.BOOL, 'success', None, None, ), # 0
15760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15761 
  )
15762 
 
15763 
  def __init__(self, success=None, ex=None,):
15764 
    self.success = success
15765 
    self.ex = ex
15766 
 
15767 
  def read(self, iprot):
15768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15770 
      return
15771 
    iprot.readStructBegin()
15772 
    while True:
15773 
      (fname, ftype, fid) = iprot.readFieldBegin()
15774 
      if ftype == TType.STOP:
15775 
        break
15776 
      if fid == 0:
15777 
        if ftype == TType.BOOL:
15778 
          self.success = iprot.readBool();
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      elif fid == 1:
15782 
        if ftype == TType.STRUCT:
15783 
          self.ex = TransactionServiceException()
15784 
          self.ex.read(iprot)
15785 
        else:
15786 
          iprot.skip(ftype)
15787 
      else:
15788 
        iprot.skip(ftype)
15789 
      iprot.readFieldEnd()
15790 
    iprot.readStructEnd()
15791 
 
15792 
  def write(self, oprot):
15793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15795 
      return
15796 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15797 
    if self.success is not None:
15798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15799 
      oprot.writeBool(self.success)
15800 
      oprot.writeFieldEnd()
15801 
    if self.ex is not None:
15802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15803 
      self.ex.write(oprot)
15804 
      oprot.writeFieldEnd()
15805 
    oprot.writeFieldStop()
15806 
    oprot.writeStructEnd()
15807 
 
15808 
  def validate(self):
15809 
    return
15810 
 
15811 
 
15812 
  def __repr__(self):
15813 
    L = ['%s=%r' % (key, value)
15814 
      for key, value in self.__dict__.iteritems()]
15815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15816 
 
15817 
  def __eq__(self, other):
15818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15819 
 
15820 
  def __ne__(self, other):
15821 
    return not (self == other)
15822 
 
4488 rajveer 15823 
class markOrderReturnRequestReceived_args:
15824 
  """
15825 
  Attributes:
15826 
   - orderId
15827 
  """
15828 
 
15829 
  thrift_spec = (
15830 
    None, # 0
15831 
    (1, TType.I64, 'orderId', None, None, ), # 1
15832 
  )
15833 
 
15834 
  def __init__(self, orderId=None,):
15835 
    self.orderId = orderId
15836 
 
15837 
  def read(self, iprot):
15838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15840 
      return
15841 
    iprot.readStructBegin()
15842 
    while True:
15843 
      (fname, ftype, fid) = iprot.readFieldBegin()
15844 
      if ftype == TType.STOP:
15845 
        break
15846 
      if fid == 1:
15847 
        if ftype == TType.I64:
15848 
          self.orderId = iprot.readI64();
15849 
        else:
15850 
          iprot.skip(ftype)
15851 
      else:
15852 
        iprot.skip(ftype)
15853 
      iprot.readFieldEnd()
15854 
    iprot.readStructEnd()
15855 
 
15856 
  def write(self, oprot):
15857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15859 
      return
15860 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15861 
    if self.orderId is not None:
15862 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15863 
      oprot.writeI64(self.orderId)
15864 
      oprot.writeFieldEnd()
15865 
    oprot.writeFieldStop()
15866 
    oprot.writeStructEnd()
15867 
 
15868 
  def validate(self):
15869 
    return
15870 
 
15871 
 
15872 
  def __repr__(self):
15873 
    L = ['%s=%r' % (key, value)
15874 
      for key, value in self.__dict__.iteritems()]
15875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15876 
 
15877 
  def __eq__(self, other):
15878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15879 
 
15880 
  def __ne__(self, other):
15881 
    return not (self == other)
15882 
 
15883 
class markOrderReturnRequestReceived_result:
15884 
  """
15885 
  Attributes:
15886 
   - success
15887 
   - ex
15888 
  """
15889 
 
15890 
  thrift_spec = (
15891 
    (0, TType.BOOL, 'success', None, None, ), # 0
15892 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15893 
  )
15894 
 
15895 
  def __init__(self, success=None, ex=None,):
15896 
    self.success = success
15897 
    self.ex = ex
15898 
 
15899 
  def read(self, iprot):
15900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15902 
      return
15903 
    iprot.readStructBegin()
15904 
    while True:
15905 
      (fname, ftype, fid) = iprot.readFieldBegin()
15906 
      if ftype == TType.STOP:
15907 
        break
15908 
      if fid == 0:
15909 
        if ftype == TType.BOOL:
15910 
          self.success = iprot.readBool();
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      elif fid == 1:
15914 
        if ftype == TType.STRUCT:
15915 
          self.ex = TransactionServiceException()
15916 
          self.ex.read(iprot)
15917 
        else:
15918 
          iprot.skip(ftype)
15919 
      else:
15920 
        iprot.skip(ftype)
15921 
      iprot.readFieldEnd()
15922 
    iprot.readStructEnd()
15923 
 
15924 
  def write(self, oprot):
15925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15927 
      return
15928 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15929 
    if self.success is not None:
15930 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15931 
      oprot.writeBool(self.success)
15932 
      oprot.writeFieldEnd()
15933 
    if self.ex is not None:
15934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15935 
      self.ex.write(oprot)
15936 
      oprot.writeFieldEnd()
15937 
    oprot.writeFieldStop()
15938 
    oprot.writeStructEnd()
15939 
 
15940 
  def validate(self):
15941 
    return
15942 
 
15943 
 
15944 
  def __repr__(self):
15945 
    L = ['%s=%r' % (key, value)
15946 
      for key, value in self.__dict__.iteritems()]
15947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15948 
 
15949 
  def __eq__(self, other):
15950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15951 
 
15952 
  def __ne__(self, other):
15953 
    return not (self == other)
15954 
 
15955 
class markOrderReturnRequestAuthorized_args:
15956 
  """
15957 
  Attributes:
15958 
   - orderId
15959 
   - isAuthorized
15960 
  """
15961 
 
15962 
  thrift_spec = (
15963 
    None, # 0
15964 
    (1, TType.I64, 'orderId', None, None, ), # 1
15965 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15966 
  )
15967 
 
15968 
  def __init__(self, orderId=None, isAuthorized=None,):
15969 
    self.orderId = orderId
15970 
    self.isAuthorized = isAuthorized
15971 
 
15972 
  def read(self, iprot):
15973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15975 
      return
15976 
    iprot.readStructBegin()
15977 
    while True:
15978 
      (fname, ftype, fid) = iprot.readFieldBegin()
15979 
      if ftype == TType.STOP:
15980 
        break
15981 
      if fid == 1:
15982 
        if ftype == TType.I64:
15983 
          self.orderId = iprot.readI64();
15984 
        else:
15985 
          iprot.skip(ftype)
15986 
      elif fid == 2:
15987 
        if ftype == TType.BOOL:
15988 
          self.isAuthorized = iprot.readBool();
15989 
        else:
15990 
          iprot.skip(ftype)
15991 
      else:
15992 
        iprot.skip(ftype)
15993 
      iprot.readFieldEnd()
15994 
    iprot.readStructEnd()
15995 
 
15996 
  def write(self, oprot):
15997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15999 
      return
16000 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16001 
    if self.orderId is not None:
16002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16003 
      oprot.writeI64(self.orderId)
16004 
      oprot.writeFieldEnd()
16005 
    if self.isAuthorized is not None:
16006 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16007 
      oprot.writeBool(self.isAuthorized)
16008 
      oprot.writeFieldEnd()
16009 
    oprot.writeFieldStop()
16010 
    oprot.writeStructEnd()
16011 
 
16012 
  def validate(self):
16013 
    return
16014 
 
16015 
 
16016 
  def __repr__(self):
16017 
    L = ['%s=%r' % (key, value)
16018 
      for key, value in self.__dict__.iteritems()]
16019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16020 
 
16021 
  def __eq__(self, other):
16022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16023 
 
16024 
  def __ne__(self, other):
16025 
    return not (self == other)
16026 
 
16027 
class markOrderReturnRequestAuthorized_result:
16028 
  """
16029 
  Attributes:
16030 
   - success
16031 
   - ex
16032 
  """
16033 
 
16034 
  thrift_spec = (
16035 
    (0, TType.BOOL, 'success', None, None, ), # 0
16036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16037 
  )
16038 
 
16039 
  def __init__(self, success=None, ex=None,):
16040 
    self.success = success
16041 
    self.ex = ex
16042 
 
16043 
  def read(self, iprot):
16044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16046 
      return
16047 
    iprot.readStructBegin()
16048 
    while True:
16049 
      (fname, ftype, fid) = iprot.readFieldBegin()
16050 
      if ftype == TType.STOP:
16051 
        break
16052 
      if fid == 0:
16053 
        if ftype == TType.BOOL:
16054 
          self.success = iprot.readBool();
16055 
        else:
16056 
          iprot.skip(ftype)
16057 
      elif fid == 1:
16058 
        if ftype == TType.STRUCT:
16059 
          self.ex = TransactionServiceException()
16060 
          self.ex.read(iprot)
16061 
        else:
16062 
          iprot.skip(ftype)
16063 
      else:
16064 
        iprot.skip(ftype)
16065 
      iprot.readFieldEnd()
16066 
    iprot.readStructEnd()
16067 
 
16068 
  def write(self, oprot):
16069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16071 
      return
16072 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16073 
    if self.success is not None:
16074 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16075 
      oprot.writeBool(self.success)
16076 
      oprot.writeFieldEnd()
16077 
    if self.ex is not None:
16078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16079 
      self.ex.write(oprot)
16080 
      oprot.writeFieldEnd()
16081 
    oprot.writeFieldStop()
16082 
    oprot.writeStructEnd()
16083 
 
16084 
  def validate(self):
16085 
    return
16086 
 
16087 
 
16088 
  def __repr__(self):
16089 
    L = ['%s=%r' % (key, value)
16090 
      for key, value in self.__dict__.iteritems()]
16091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16092 
 
16093 
  def __eq__(self, other):
16094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16095 
 
16096 
  def __ne__(self, other):
16097 
    return not (self == other)
16098 
 
2536 chandransh 16099 
class requestPickupNumber_args:
16100 
  """
16101 
  Attributes:
16102 
   - orderId
4579 rajveer 16103 
   - providerId
2536 chandransh 16104 
  """
16105 
 
16106 
  thrift_spec = (
16107 
    None, # 0
16108 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16109 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16110 
  )
16111 
 
4579 rajveer 16112 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16113 
    self.orderId = orderId
4579 rajveer 16114 
    self.providerId = providerId
2536 chandransh 16115 
 
16116 
  def read(self, iprot):
16117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16119 
      return
16120 
    iprot.readStructBegin()
16121 
    while True:
16122 
      (fname, ftype, fid) = iprot.readFieldBegin()
16123 
      if ftype == TType.STOP:
16124 
        break
16125 
      if fid == 1:
16126 
        if ftype == TType.I64:
16127 
          self.orderId = iprot.readI64();
16128 
        else:
16129 
          iprot.skip(ftype)
4579 rajveer 16130 
      elif fid == 2:
16131 
        if ftype == TType.I64:
16132 
          self.providerId = iprot.readI64();
16133 
        else:
16134 
          iprot.skip(ftype)
2536 chandransh 16135 
      else:
16136 
        iprot.skip(ftype)
16137 
      iprot.readFieldEnd()
16138 
    iprot.readStructEnd()
16139 
 
16140 
  def write(self, oprot):
16141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16143 
      return
16144 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16145 
    if self.orderId is not None:
2536 chandransh 16146 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16147 
      oprot.writeI64(self.orderId)
16148 
      oprot.writeFieldEnd()
4579 rajveer 16149 
    if self.providerId is not None:
16150 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16151 
      oprot.writeI64(self.providerId)
16152 
      oprot.writeFieldEnd()
2536 chandransh 16153 
    oprot.writeFieldStop()
16154 
    oprot.writeStructEnd()
16155 
 
3431 rajveer 16156 
  def validate(self):
16157 
    return
16158 
 
16159 
 
2536 chandransh 16160 
  def __repr__(self):
16161 
    L = ['%s=%r' % (key, value)
16162 
      for key, value in self.__dict__.iteritems()]
16163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16164 
 
16165 
  def __eq__(self, other):
16166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16167 
 
16168 
  def __ne__(self, other):
16169 
    return not (self == other)
16170 
 
16171 
class requestPickupNumber_result:
16172 
  """
16173 
  Attributes:
16174 
   - success
16175 
   - ex
16176 
  """
16177 
 
16178 
  thrift_spec = (
16179 
    (0, TType.BOOL, 'success', None, None, ), # 0
16180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16181 
  )
16182 
 
16183 
  def __init__(self, success=None, ex=None,):
16184 
    self.success = success
16185 
    self.ex = ex
16186 
 
16187 
  def read(self, iprot):
16188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16190 
      return
16191 
    iprot.readStructBegin()
16192 
    while True:
16193 
      (fname, ftype, fid) = iprot.readFieldBegin()
16194 
      if ftype == TType.STOP:
16195 
        break
16196 
      if fid == 0:
16197 
        if ftype == TType.BOOL:
16198 
          self.success = iprot.readBool();
16199 
        else:
16200 
          iprot.skip(ftype)
16201 
      elif fid == 1:
16202 
        if ftype == TType.STRUCT:
16203 
          self.ex = TransactionServiceException()
16204 
          self.ex.read(iprot)
16205 
        else:
16206 
          iprot.skip(ftype)
16207 
      else:
16208 
        iprot.skip(ftype)
16209 
      iprot.readFieldEnd()
16210 
    iprot.readStructEnd()
16211 
 
16212 
  def write(self, oprot):
16213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16215 
      return
16216 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16217 
    if self.success is not None:
2536 chandransh 16218 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16219 
      oprot.writeBool(self.success)
16220 
      oprot.writeFieldEnd()
3431 rajveer 16221 
    if self.ex is not None:
2536 chandransh 16222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16223 
      self.ex.write(oprot)
16224 
      oprot.writeFieldEnd()
16225 
    oprot.writeFieldStop()
16226 
    oprot.writeStructEnd()
16227 
 
3431 rajveer 16228 
  def validate(self):
16229 
    return
16230 
 
16231 
 
2536 chandransh 16232 
  def __repr__(self):
16233 
    L = ['%s=%r' % (key, value)
16234 
      for key, value in self.__dict__.iteritems()]
16235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16236 
 
16237 
  def __eq__(self, other):
16238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16239 
 
16240 
  def __ne__(self, other):
16241 
    return not (self == other)
16242 
 
16243 
class authorizePickup_args:
16244 
  """
16245 
  Attributes:
16246 
   - orderId
16247 
   - pickupNumber
4602 rajveer 16248 
   - providerId
2536 chandransh 16249 
  """
16250 
 
16251 
  thrift_spec = (
16252 
    None, # 0
16253 
    (1, TType.I64, 'orderId', None, None, ), # 1
16254 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16255 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16256 
  )
16257 
 
4602 rajveer 16258 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16259 
    self.orderId = orderId
16260 
    self.pickupNumber = pickupNumber
4602 rajveer 16261 
    self.providerId = providerId
2536 chandransh 16262 
 
16263 
  def read(self, iprot):
16264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16266 
      return
16267 
    iprot.readStructBegin()
16268 
    while True:
16269 
      (fname, ftype, fid) = iprot.readFieldBegin()
16270 
      if ftype == TType.STOP:
16271 
        break
16272 
      if fid == 1:
16273 
        if ftype == TType.I64:
16274 
          self.orderId = iprot.readI64();
16275 
        else:
16276 
          iprot.skip(ftype)
16277 
      elif fid == 2:
16278 
        if ftype == TType.STRING:
16279 
          self.pickupNumber = iprot.readString();
16280 
        else:
16281 
          iprot.skip(ftype)
4602 rajveer 16282 
      elif fid == 3:
16283 
        if ftype == TType.I64:
16284 
          self.providerId = iprot.readI64();
16285 
        else:
16286 
          iprot.skip(ftype)
2536 chandransh 16287 
      else:
16288 
        iprot.skip(ftype)
16289 
      iprot.readFieldEnd()
16290 
    iprot.readStructEnd()
16291 
 
16292 
  def write(self, oprot):
16293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16295 
      return
16296 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16297 
    if self.orderId is not None:
2536 chandransh 16298 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16299 
      oprot.writeI64(self.orderId)
16300 
      oprot.writeFieldEnd()
3431 rajveer 16301 
    if self.pickupNumber is not None:
2536 chandransh 16302 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16303 
      oprot.writeString(self.pickupNumber)
16304 
      oprot.writeFieldEnd()
4602 rajveer 16305 
    if self.providerId is not None:
16306 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16307 
      oprot.writeI64(self.providerId)
16308 
      oprot.writeFieldEnd()
2536 chandransh 16309 
    oprot.writeFieldStop()
16310 
    oprot.writeStructEnd()
16311 
 
3431 rajveer 16312 
  def validate(self):
16313 
    return
16314 
 
16315 
 
2536 chandransh 16316 
  def __repr__(self):
16317 
    L = ['%s=%r' % (key, value)
16318 
      for key, value in self.__dict__.iteritems()]
16319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16320 
 
16321 
  def __eq__(self, other):
16322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16323 
 
16324 
  def __ne__(self, other):
16325 
    return not (self == other)
16326 
 
16327 
class authorizePickup_result:
16328 
  """
16329 
  Attributes:
16330 
   - success
16331 
   - ex
16332 
  """
16333 
 
16334 
  thrift_spec = (
16335 
    (0, TType.BOOL, 'success', None, None, ), # 0
16336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16337 
  )
16338 
 
16339 
  def __init__(self, success=None, ex=None,):
16340 
    self.success = success
16341 
    self.ex = ex
16342 
 
16343 
  def read(self, iprot):
16344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16346 
      return
16347 
    iprot.readStructBegin()
16348 
    while True:
16349 
      (fname, ftype, fid) = iprot.readFieldBegin()
16350 
      if ftype == TType.STOP:
16351 
        break
16352 
      if fid == 0:
16353 
        if ftype == TType.BOOL:
16354 
          self.success = iprot.readBool();
16355 
        else:
16356 
          iprot.skip(ftype)
16357 
      elif fid == 1:
16358 
        if ftype == TType.STRUCT:
16359 
          self.ex = TransactionServiceException()
16360 
          self.ex.read(iprot)
16361 
        else:
16362 
          iprot.skip(ftype)
16363 
      else:
16364 
        iprot.skip(ftype)
16365 
      iprot.readFieldEnd()
16366 
    iprot.readStructEnd()
16367 
 
16368 
  def write(self, oprot):
16369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16371 
      return
16372 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16373 
    if self.success is not None:
2536 chandransh 16374 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16375 
      oprot.writeBool(self.success)
16376 
      oprot.writeFieldEnd()
3431 rajveer 16377 
    if self.ex is not None:
2536 chandransh 16378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16379 
      self.ex.write(oprot)
16380 
      oprot.writeFieldEnd()
16381 
    oprot.writeFieldStop()
16382 
    oprot.writeStructEnd()
16383 
 
3431 rajveer 16384 
  def validate(self):
16385 
    return
16386 
 
16387 
 
2536 chandransh 16388 
  def __repr__(self):
16389 
    L = ['%s=%r' % (key, value)
16390 
      for key, value in self.__dict__.iteritems()]
16391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16392 
 
16393 
  def __eq__(self, other):
16394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16395 
 
16396 
  def __ne__(self, other):
16397 
    return not (self == other)
16398 
 
2764 chandransh 16399 
class markDoasAsPickedUp_args:
16400 
  """
16401 
  Attributes:
16402 
   - providerId
16403 
   - pickupDetails
16404 
  """
16405 
 
16406 
  thrift_spec = (
16407 
    None, # 0
16408 
    (1, TType.I64, 'providerId', None, None, ), # 1
16409 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16410 
  )
16411 
 
16412 
  def __init__(self, providerId=None, pickupDetails=None,):
16413 
    self.providerId = providerId
16414 
    self.pickupDetails = pickupDetails
16415 
 
16416 
  def read(self, iprot):
16417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16419 
      return
16420 
    iprot.readStructBegin()
16421 
    while True:
16422 
      (fname, ftype, fid) = iprot.readFieldBegin()
16423 
      if ftype == TType.STOP:
16424 
        break
16425 
      if fid == 1:
16426 
        if ftype == TType.I64:
16427 
          self.providerId = iprot.readI64();
16428 
        else:
16429 
          iprot.skip(ftype)
16430 
      elif fid == 2:
16431 
        if ftype == TType.MAP:
16432 
          self.pickupDetails = {}
6000 mandeep.dh 16433 
          (_ktype372, _vtype373, _size371 ) = iprot.readMapBegin()
16434 
          for _i375 in xrange(_size371):
16435 
            _key376 = iprot.readString();
16436 
            _val377 = iprot.readString();
16437 
            self.pickupDetails[_key376] = _val377
2764 chandransh 16438 
          iprot.readMapEnd()
16439 
        else:
16440 
          iprot.skip(ftype)
16441 
      else:
16442 
        iprot.skip(ftype)
16443 
      iprot.readFieldEnd()
16444 
    iprot.readStructEnd()
16445 
 
16446 
  def write(self, oprot):
16447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16449 
      return
16450 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16451 
    if self.providerId is not None:
2764 chandransh 16452 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16453 
      oprot.writeI64(self.providerId)
16454 
      oprot.writeFieldEnd()
3431 rajveer 16455 
    if self.pickupDetails is not None:
2764 chandransh 16456 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16457 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 16458 
      for kiter378,viter379 in self.pickupDetails.items():
16459 
        oprot.writeString(kiter378)
16460 
        oprot.writeString(viter379)
2764 chandransh 16461 
      oprot.writeMapEnd()
16462 
      oprot.writeFieldEnd()
16463 
    oprot.writeFieldStop()
16464 
    oprot.writeStructEnd()
16465 
 
3431 rajveer 16466 
  def validate(self):
16467 
    return
16468 
 
16469 
 
2764 chandransh 16470 
  def __repr__(self):
16471 
    L = ['%s=%r' % (key, value)
16472 
      for key, value in self.__dict__.iteritems()]
16473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16474 
 
16475 
  def __eq__(self, other):
16476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16477 
 
16478 
  def __ne__(self, other):
16479 
    return not (self == other)
16480 
 
16481 
class markDoasAsPickedUp_result:
4910 phani.kuma 16482 
 
16483 
  thrift_spec = (
16484 
  )
16485 
 
16486 
  def read(self, iprot):
16487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16489 
      return
16490 
    iprot.readStructBegin()
16491 
    while True:
16492 
      (fname, ftype, fid) = iprot.readFieldBegin()
16493 
      if ftype == TType.STOP:
16494 
        break
16495 
      else:
16496 
        iprot.skip(ftype)
16497 
      iprot.readFieldEnd()
16498 
    iprot.readStructEnd()
16499 
 
16500 
  def write(self, oprot):
16501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16503 
      return
16504 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16505 
    oprot.writeFieldStop()
16506 
    oprot.writeStructEnd()
16507 
 
16508 
  def validate(self):
16509 
    return
16510 
 
16511 
 
16512 
  def __repr__(self):
16513 
    L = ['%s=%r' % (key, value)
16514 
      for key, value in self.__dict__.iteritems()]
16515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16516 
 
16517 
  def __eq__(self, other):
16518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16519 
 
16520 
  def __ne__(self, other):
16521 
    return not (self == other)
16522 
 
16523 
class getDoasNotPickedUp_args:
2764 chandransh 16524 
  """
16525 
  Attributes:
4910 phani.kuma 16526 
   - providerId
16527 
  """
16528 
 
16529 
  thrift_spec = (
16530 
    None, # 0
16531 
    (1, TType.I64, 'providerId', None, None, ), # 1
16532 
  )
16533 
 
16534 
  def __init__(self, providerId=None,):
16535 
    self.providerId = providerId
16536 
 
16537 
  def read(self, iprot):
16538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16540 
      return
16541 
    iprot.readStructBegin()
16542 
    while True:
16543 
      (fname, ftype, fid) = iprot.readFieldBegin()
16544 
      if ftype == TType.STOP:
16545 
        break
16546 
      if fid == 1:
16547 
        if ftype == TType.I64:
16548 
          self.providerId = iprot.readI64();
16549 
        else:
16550 
          iprot.skip(ftype)
16551 
      else:
16552 
        iprot.skip(ftype)
16553 
      iprot.readFieldEnd()
16554 
    iprot.readStructEnd()
16555 
 
16556 
  def write(self, oprot):
16557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16559 
      return
16560 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16561 
    if self.providerId is not None:
16562 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16563 
      oprot.writeI64(self.providerId)
16564 
      oprot.writeFieldEnd()
16565 
    oprot.writeFieldStop()
16566 
    oprot.writeStructEnd()
16567 
 
16568 
  def validate(self):
16569 
    return
16570 
 
16571 
 
16572 
  def __repr__(self):
16573 
    L = ['%s=%r' % (key, value)
16574 
      for key, value in self.__dict__.iteritems()]
16575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16576 
 
16577 
  def __eq__(self, other):
16578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16579 
 
16580 
  def __ne__(self, other):
16581 
    return not (self == other)
16582 
 
16583 
class getDoasNotPickedUp_result:
16584 
  """
16585 
  Attributes:
2764 chandransh 16586 
   - success
16587 
  """
16588 
 
16589 
  thrift_spec = (
16590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16591 
  )
16592 
 
16593 
  def __init__(self, success=None,):
16594 
    self.success = success
16595 
 
16596 
  def read(self, iprot):
16597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16599 
      return
16600 
    iprot.readStructBegin()
16601 
    while True:
16602 
      (fname, ftype, fid) = iprot.readFieldBegin()
16603 
      if ftype == TType.STOP:
16604 
        break
16605 
      if fid == 0:
16606 
        if ftype == TType.LIST:
16607 
          self.success = []
6000 mandeep.dh 16608 
          (_etype383, _size380) = iprot.readListBegin()
16609 
          for _i384 in xrange(_size380):
16610 
            _elem385 = Order()
16611 
            _elem385.read(iprot)
16612 
            self.success.append(_elem385)
2764 chandransh 16613 
          iprot.readListEnd()
16614 
        else:
16615 
          iprot.skip(ftype)
16616 
      else:
16617 
        iprot.skip(ftype)
16618 
      iprot.readFieldEnd()
16619 
    iprot.readStructEnd()
16620 
 
16621 
  def write(self, oprot):
16622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16624 
      return
4910 phani.kuma 16625 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16626 
    if self.success is not None:
2764 chandransh 16627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 16629 
      for iter386 in self.success:
16630 
        iter386.write(oprot)
2764 chandransh 16631 
      oprot.writeListEnd()
16632 
      oprot.writeFieldEnd()
16633 
    oprot.writeFieldStop()
16634 
    oprot.writeStructEnd()
16635 
 
3431 rajveer 16636 
  def validate(self):
16637 
    return
16638 
 
16639 
 
2764 chandransh 16640 
  def __repr__(self):
16641 
    L = ['%s=%r' % (key, value)
16642 
      for key, value in self.__dict__.iteritems()]
16643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16644 
 
16645 
  def __eq__(self, other):
16646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16647 
 
16648 
  def __ne__(self, other):
16649 
    return not (self == other)
16650 
 
4741 phani.kuma 16651 
class markReturnOrdersAsPickedUp_args:
16652 
  """
16653 
  Attributes:
16654 
   - providerId
16655 
   - pickupDetails
16656 
  """
16657 
 
16658 
  thrift_spec = (
16659 
    None, # 0
16660 
    (1, TType.I64, 'providerId', None, None, ), # 1
16661 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16662 
  )
16663 
 
16664 
  def __init__(self, providerId=None, pickupDetails=None,):
16665 
    self.providerId = providerId
16666 
    self.pickupDetails = pickupDetails
16667 
 
16668 
  def read(self, iprot):
16669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16671 
      return
16672 
    iprot.readStructBegin()
16673 
    while True:
16674 
      (fname, ftype, fid) = iprot.readFieldBegin()
16675 
      if ftype == TType.STOP:
16676 
        break
16677 
      if fid == 1:
16678 
        if ftype == TType.I64:
16679 
          self.providerId = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      elif fid == 2:
16683 
        if ftype == TType.MAP:
16684 
          self.pickupDetails = {}
6000 mandeep.dh 16685 
          (_ktype388, _vtype389, _size387 ) = iprot.readMapBegin()
16686 
          for _i391 in xrange(_size387):
16687 
            _key392 = iprot.readString();
16688 
            _val393 = iprot.readString();
16689 
            self.pickupDetails[_key392] = _val393
4741 phani.kuma 16690 
          iprot.readMapEnd()
16691 
        else:
16692 
          iprot.skip(ftype)
16693 
      else:
16694 
        iprot.skip(ftype)
16695 
      iprot.readFieldEnd()
16696 
    iprot.readStructEnd()
16697 
 
16698 
  def write(self, oprot):
16699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16701 
      return
16702 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16703 
    if self.providerId is not None:
16704 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16705 
      oprot.writeI64(self.providerId)
16706 
      oprot.writeFieldEnd()
16707 
    if self.pickupDetails is not None:
16708 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16709 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 16710 
      for kiter394,viter395 in self.pickupDetails.items():
16711 
        oprot.writeString(kiter394)
16712 
        oprot.writeString(viter395)
4741 phani.kuma 16713 
      oprot.writeMapEnd()
16714 
      oprot.writeFieldEnd()
16715 
    oprot.writeFieldStop()
16716 
    oprot.writeStructEnd()
16717 
 
16718 
  def validate(self):
16719 
    return
16720 
 
16721 
 
16722 
  def __repr__(self):
16723 
    L = ['%s=%r' % (key, value)
16724 
      for key, value in self.__dict__.iteritems()]
16725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16726 
 
16727 
  def __eq__(self, other):
16728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16729 
 
16730 
  def __ne__(self, other):
16731 
    return not (self == other)
16732 
 
16733 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16734 
 
16735 
  thrift_spec = (
16736 
  )
16737 
 
16738 
  def read(self, iprot):
16739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16741 
      return
16742 
    iprot.readStructBegin()
16743 
    while True:
16744 
      (fname, ftype, fid) = iprot.readFieldBegin()
16745 
      if ftype == TType.STOP:
16746 
        break
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
16756 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16757 
    oprot.writeFieldStop()
16758 
    oprot.writeStructEnd()
16759 
 
16760 
  def validate(self):
16761 
    return
16762 
 
16763 
 
16764 
  def __repr__(self):
16765 
    L = ['%s=%r' % (key, value)
16766 
      for key, value in self.__dict__.iteritems()]
16767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16768 
 
16769 
  def __eq__(self, other):
16770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16771 
 
16772 
  def __ne__(self, other):
16773 
    return not (self == other)
16774 
 
16775 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16776 
  """
16777 
  Attributes:
4910 phani.kuma 16778 
   - providerId
16779 
  """
16780 
 
16781 
  thrift_spec = (
16782 
    None, # 0
16783 
    (1, TType.I64, 'providerId', None, None, ), # 1
16784 
  )
16785 
 
16786 
  def __init__(self, providerId=None,):
16787 
    self.providerId = providerId
16788 
 
16789 
  def read(self, iprot):
16790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16792 
      return
16793 
    iprot.readStructBegin()
16794 
    while True:
16795 
      (fname, ftype, fid) = iprot.readFieldBegin()
16796 
      if ftype == TType.STOP:
16797 
        break
16798 
      if fid == 1:
16799 
        if ftype == TType.I64:
16800 
          self.providerId = iprot.readI64();
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      else:
16804 
        iprot.skip(ftype)
16805 
      iprot.readFieldEnd()
16806 
    iprot.readStructEnd()
16807 
 
16808 
  def write(self, oprot):
16809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16811 
      return
16812 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16813 
    if self.providerId is not None:
16814 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16815 
      oprot.writeI64(self.providerId)
16816 
      oprot.writeFieldEnd()
16817 
    oprot.writeFieldStop()
16818 
    oprot.writeStructEnd()
16819 
 
16820 
  def validate(self):
16821 
    return
16822 
 
16823 
 
16824 
  def __repr__(self):
16825 
    L = ['%s=%r' % (key, value)
16826 
      for key, value in self.__dict__.iteritems()]
16827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16828 
 
16829 
  def __eq__(self, other):
16830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16831 
 
16832 
  def __ne__(self, other):
16833 
    return not (self == other)
16834 
 
16835 
class getReturnOrdersNotPickedUp_result:
16836 
  """
16837 
  Attributes:
4741 phani.kuma 16838 
   - success
16839 
  """
16840 
 
16841 
  thrift_spec = (
16842 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16843 
  )
16844 
 
16845 
  def __init__(self, success=None,):
16846 
    self.success = success
16847 
 
16848 
  def read(self, iprot):
16849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16851 
      return
16852 
    iprot.readStructBegin()
16853 
    while True:
16854 
      (fname, ftype, fid) = iprot.readFieldBegin()
16855 
      if ftype == TType.STOP:
16856 
        break
16857 
      if fid == 0:
16858 
        if ftype == TType.LIST:
16859 
          self.success = []
6000 mandeep.dh 16860 
          (_etype399, _size396) = iprot.readListBegin()
16861 
          for _i400 in xrange(_size396):
16862 
            _elem401 = Order()
16863 
            _elem401.read(iprot)
16864 
            self.success.append(_elem401)
4741 phani.kuma 16865 
          iprot.readListEnd()
16866 
        else:
16867 
          iprot.skip(ftype)
16868 
      else:
16869 
        iprot.skip(ftype)
16870 
      iprot.readFieldEnd()
16871 
    iprot.readStructEnd()
16872 
 
16873 
  def write(self, oprot):
16874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16876 
      return
4910 phani.kuma 16877 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16878 
    if self.success is not None:
16879 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16880 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 16881 
      for iter402 in self.success:
16882 
        iter402.write(oprot)
4741 phani.kuma 16883 
      oprot.writeListEnd()
16884 
      oprot.writeFieldEnd()
16885 
    oprot.writeFieldStop()
16886 
    oprot.writeStructEnd()
16887 
 
16888 
  def validate(self):
16889 
    return
16890 
 
16891 
 
16892 
  def __repr__(self):
16893 
    L = ['%s=%r' % (key, value)
16894 
      for key, value in self.__dict__.iteritems()]
16895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16896 
 
16897 
  def __eq__(self, other):
16898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16899 
 
16900 
  def __ne__(self, other):
16901 
    return not (self == other)
16902 
 
2616 chandransh 16903 
class receiveReturn_args:
2591 chandransh 16904 
  """
16905 
  Attributes:
16906 
   - orderId
4479 rajveer 16907 
   - receiveCondition
2591 chandransh 16908 
  """
2536 chandransh 16909 
 
2591 chandransh 16910 
  thrift_spec = (
16911 
    None, # 0
16912 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16913 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16914 
  )
16915 
 
4479 rajveer 16916 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16917 
    self.orderId = orderId
4479 rajveer 16918 
    self.receiveCondition = receiveCondition
2591 chandransh 16919 
 
16920 
  def read(self, iprot):
16921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16923 
      return
16924 
    iprot.readStructBegin()
16925 
    while True:
16926 
      (fname, ftype, fid) = iprot.readFieldBegin()
16927 
      if ftype == TType.STOP:
16928 
        break
16929 
      if fid == 1:
16930 
        if ftype == TType.I64:
16931 
          self.orderId = iprot.readI64();
16932 
        else:
16933 
          iprot.skip(ftype)
4479 rajveer 16934 
      elif fid == 2:
16935 
        if ftype == TType.I64:
16936 
          self.receiveCondition = iprot.readI64();
16937 
        else:
16938 
          iprot.skip(ftype)
2591 chandransh 16939 
      else:
16940 
        iprot.skip(ftype)
16941 
      iprot.readFieldEnd()
16942 
    iprot.readStructEnd()
16943 
 
16944 
  def write(self, oprot):
16945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16947 
      return
2616 chandransh 16948 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16949 
    if self.orderId is not None:
2591 chandransh 16950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16951 
      oprot.writeI64(self.orderId)
16952 
      oprot.writeFieldEnd()
4479 rajveer 16953 
    if self.receiveCondition is not None:
16954 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16955 
      oprot.writeI64(self.receiveCondition)
16956 
      oprot.writeFieldEnd()
2591 chandransh 16957 
    oprot.writeFieldStop()
16958 
    oprot.writeStructEnd()
16959 
 
3431 rajveer 16960 
  def validate(self):
16961 
    return
16962 
 
16963 
 
2591 chandransh 16964 
  def __repr__(self):
16965 
    L = ['%s=%r' % (key, value)
16966 
      for key, value in self.__dict__.iteritems()]
16967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16968 
 
16969 
  def __eq__(self, other):
16970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16971 
 
16972 
  def __ne__(self, other):
16973 
    return not (self == other)
16974 
 
2616 chandransh 16975 
class receiveReturn_result:
2591 chandransh 16976 
  """
16977 
  Attributes:
16978 
   - success
16979 
   - ex
16980 
  """
16981 
 
16982 
  thrift_spec = (
16983 
    (0, TType.BOOL, 'success', None, None, ), # 0
16984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16985 
  )
16986 
 
16987 
  def __init__(self, success=None, ex=None,):
16988 
    self.success = success
16989 
    self.ex = ex
16990 
 
16991 
  def read(self, iprot):
16992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16994 
      return
16995 
    iprot.readStructBegin()
16996 
    while True:
16997 
      (fname, ftype, fid) = iprot.readFieldBegin()
16998 
      if ftype == TType.STOP:
16999 
        break
17000 
      if fid == 0:
17001 
        if ftype == TType.BOOL:
17002 
          self.success = iprot.readBool();
17003 
        else:
17004 
          iprot.skip(ftype)
17005 
      elif fid == 1:
17006 
        if ftype == TType.STRUCT:
17007 
          self.ex = TransactionServiceException()
17008 
          self.ex.read(iprot)
17009 
        else:
17010 
          iprot.skip(ftype)
17011 
      else:
17012 
        iprot.skip(ftype)
17013 
      iprot.readFieldEnd()
17014 
    iprot.readStructEnd()
17015 
 
17016 
  def write(self, oprot):
17017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17019 
      return
2616 chandransh 17020 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17021 
    if self.success is not None:
2591 chandransh 17022 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17023 
      oprot.writeBool(self.success)
17024 
      oprot.writeFieldEnd()
3431 rajveer 17025 
    if self.ex is not None:
2591 chandransh 17026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17027 
      self.ex.write(oprot)
17028 
      oprot.writeFieldEnd()
17029 
    oprot.writeFieldStop()
17030 
    oprot.writeStructEnd()
17031 
 
3431 rajveer 17032 
  def validate(self):
17033 
    return
17034 
 
17035 
 
2591 chandransh 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 validateDoa_args:
17048 
  """
17049 
  Attributes:
17050 
   - orderId
17051 
   - isValid
17052 
  """
17053 
 
17054 
  thrift_spec = (
17055 
    None, # 0
17056 
    (1, TType.I64, 'orderId', None, None, ), # 1
17057 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17058 
  )
17059 
 
17060 
  def __init__(self, orderId=None, isValid=None,):
17061 
    self.orderId = orderId
17062 
    self.isValid = isValid
17063 
 
17064 
  def read(self, iprot):
17065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17067 
      return
17068 
    iprot.readStructBegin()
17069 
    while True:
17070 
      (fname, ftype, fid) = iprot.readFieldBegin()
17071 
      if ftype == TType.STOP:
17072 
        break
17073 
      if fid == 1:
17074 
        if ftype == TType.I64:
17075 
          self.orderId = iprot.readI64();
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      elif fid == 2:
17079 
        if ftype == TType.BOOL:
17080 
          self.isValid = iprot.readBool();
17081 
        else:
17082 
          iprot.skip(ftype)
17083 
      else:
17084 
        iprot.skip(ftype)
17085 
      iprot.readFieldEnd()
17086 
    iprot.readStructEnd()
17087 
 
17088 
  def write(self, oprot):
17089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17091 
      return
17092 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17093 
    if self.orderId is not None:
2591 chandransh 17094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17095 
      oprot.writeI64(self.orderId)
17096 
      oprot.writeFieldEnd()
3431 rajveer 17097 
    if self.isValid is not None:
2591 chandransh 17098 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17099 
      oprot.writeBool(self.isValid)
17100 
      oprot.writeFieldEnd()
17101 
    oprot.writeFieldStop()
17102 
    oprot.writeStructEnd()
17103 
 
3431 rajveer 17104 
  def validate(self):
17105 
    return
17106 
 
17107 
 
2591 chandransh 17108 
  def __repr__(self):
17109 
    L = ['%s=%r' % (key, value)
17110 
      for key, value in self.__dict__.iteritems()]
17111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17112 
 
17113 
  def __eq__(self, other):
17114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17115 
 
17116 
  def __ne__(self, other):
17117 
    return not (self == other)
17118 
 
17119 
class validateDoa_result:
17120 
  """
17121 
  Attributes:
17122 
   - success
17123 
   - ex
17124 
  """
17125 
 
17126 
  thrift_spec = (
17127 
    (0, TType.BOOL, 'success', None, None, ), # 0
17128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17129 
  )
17130 
 
17131 
  def __init__(self, success=None, ex=None,):
17132 
    self.success = success
17133 
    self.ex = ex
17134 
 
17135 
  def read(self, iprot):
17136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17138 
      return
17139 
    iprot.readStructBegin()
17140 
    while True:
17141 
      (fname, ftype, fid) = iprot.readFieldBegin()
17142 
      if ftype == TType.STOP:
17143 
        break
17144 
      if fid == 0:
17145 
        if ftype == TType.BOOL:
17146 
          self.success = iprot.readBool();
17147 
        else:
17148 
          iprot.skip(ftype)
17149 
      elif fid == 1:
17150 
        if ftype == TType.STRUCT:
17151 
          self.ex = TransactionServiceException()
17152 
          self.ex.read(iprot)
17153 
        else:
17154 
          iprot.skip(ftype)
17155 
      else:
17156 
        iprot.skip(ftype)
17157 
      iprot.readFieldEnd()
17158 
    iprot.readStructEnd()
17159 
 
17160 
  def write(self, oprot):
17161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17163 
      return
17164 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17165 
    if self.success is not None:
2591 chandransh 17166 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17167 
      oprot.writeBool(self.success)
17168 
      oprot.writeFieldEnd()
3431 rajveer 17169 
    if self.ex is not None:
2591 chandransh 17170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17171 
      self.ex.write(oprot)
17172 
      oprot.writeFieldEnd()
17173 
    oprot.writeFieldStop()
17174 
    oprot.writeStructEnd()
17175 
 
3431 rajveer 17176 
  def validate(self):
17177 
    return
17178 
 
17179 
 
2591 chandransh 17180 
  def __repr__(self):
17181 
    L = ['%s=%r' % (key, value)
17182 
      for key, value in self.__dict__.iteritems()]
17183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17184 
 
17185 
  def __eq__(self, other):
17186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17187 
 
17188 
  def __ne__(self, other):
17189 
    return not (self == other)
17190 
 
4495 rajveer 17191 
class validateReturnProduct_args:
17192 
  """
17193 
  Attributes:
17194 
   - orderId
17195 
   - isUsable
17196 
  """
17197 
 
17198 
  thrift_spec = (
17199 
    None, # 0
17200 
    (1, TType.I64, 'orderId', None, None, ), # 1
17201 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17202 
  )
17203 
 
17204 
  def __init__(self, orderId=None, isUsable=None,):
17205 
    self.orderId = orderId
17206 
    self.isUsable = isUsable
17207 
 
17208 
  def read(self, iprot):
17209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17211 
      return
17212 
    iprot.readStructBegin()
17213 
    while True:
17214 
      (fname, ftype, fid) = iprot.readFieldBegin()
17215 
      if ftype == TType.STOP:
17216 
        break
17217 
      if fid == 1:
17218 
        if ftype == TType.I64:
17219 
          self.orderId = iprot.readI64();
17220 
        else:
17221 
          iprot.skip(ftype)
17222 
      elif fid == 2:
17223 
        if ftype == TType.BOOL:
17224 
          self.isUsable = iprot.readBool();
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      else:
17228 
        iprot.skip(ftype)
17229 
      iprot.readFieldEnd()
17230 
    iprot.readStructEnd()
17231 
 
17232 
  def write(self, oprot):
17233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17235 
      return
17236 
    oprot.writeStructBegin('validateReturnProduct_args')
17237 
    if self.orderId is not None:
17238 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17239 
      oprot.writeI64(self.orderId)
17240 
      oprot.writeFieldEnd()
17241 
    if self.isUsable is not None:
17242 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17243 
      oprot.writeBool(self.isUsable)
17244 
      oprot.writeFieldEnd()
17245 
    oprot.writeFieldStop()
17246 
    oprot.writeStructEnd()
17247 
 
17248 
  def validate(self):
17249 
    return
17250 
 
17251 
 
17252 
  def __repr__(self):
17253 
    L = ['%s=%r' % (key, value)
17254 
      for key, value in self.__dict__.iteritems()]
17255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17256 
 
17257 
  def __eq__(self, other):
17258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17259 
 
17260 
  def __ne__(self, other):
17261 
    return not (self == other)
17262 
 
17263 
class validateReturnProduct_result:
17264 
  """
17265 
  Attributes:
17266 
   - success
17267 
   - ex
17268 
  """
17269 
 
17270 
  thrift_spec = (
17271 
    (0, TType.BOOL, 'success', None, None, ), # 0
17272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17273 
  )
17274 
 
17275 
  def __init__(self, success=None, ex=None,):
17276 
    self.success = success
17277 
    self.ex = ex
17278 
 
17279 
  def read(self, iprot):
17280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17282 
      return
17283 
    iprot.readStructBegin()
17284 
    while True:
17285 
      (fname, ftype, fid) = iprot.readFieldBegin()
17286 
      if ftype == TType.STOP:
17287 
        break
17288 
      if fid == 0:
17289 
        if ftype == TType.BOOL:
17290 
          self.success = iprot.readBool();
17291 
        else:
17292 
          iprot.skip(ftype)
17293 
      elif fid == 1:
17294 
        if ftype == TType.STRUCT:
17295 
          self.ex = TransactionServiceException()
17296 
          self.ex.read(iprot)
17297 
        else:
17298 
          iprot.skip(ftype)
17299 
      else:
17300 
        iprot.skip(ftype)
17301 
      iprot.readFieldEnd()
17302 
    iprot.readStructEnd()
17303 
 
17304 
  def write(self, oprot):
17305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17307 
      return
17308 
    oprot.writeStructBegin('validateReturnProduct_result')
17309 
    if self.success is not None:
17310 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17311 
      oprot.writeBool(self.success)
17312 
      oprot.writeFieldEnd()
17313 
    if self.ex is not None:
17314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17315 
      self.ex.write(oprot)
17316 
      oprot.writeFieldEnd()
17317 
    oprot.writeFieldStop()
17318 
    oprot.writeStructEnd()
17319 
 
17320 
  def validate(self):
17321 
    return
17322 
 
17323 
 
17324 
  def __repr__(self):
17325 
    L = ['%s=%r' % (key, value)
17326 
      for key, value in self.__dict__.iteritems()]
17327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17328 
 
17329 
  def __eq__(self, other):
17330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17331 
 
17332 
  def __ne__(self, other):
17333 
    return not (self == other)
17334 
 
2616 chandransh 17335 
class reshipOrder_args:
17336 
  """
17337 
  Attributes:
17338 
   - orderId
17339 
  """
2591 chandransh 17340 
 
2616 chandransh 17341 
  thrift_spec = (
17342 
    None, # 0
17343 
    (1, TType.I64, 'orderId', None, None, ), # 1
17344 
  )
17345 
 
17346 
  def __init__(self, orderId=None,):
17347 
    self.orderId = orderId
17348 
 
17349 
  def read(self, iprot):
17350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17352 
      return
17353 
    iprot.readStructBegin()
17354 
    while True:
17355 
      (fname, ftype, fid) = iprot.readFieldBegin()
17356 
      if ftype == TType.STOP:
17357 
        break
17358 
      if fid == 1:
17359 
        if ftype == TType.I64:
17360 
          self.orderId = iprot.readI64();
17361 
        else:
17362 
          iprot.skip(ftype)
17363 
      else:
17364 
        iprot.skip(ftype)
17365 
      iprot.readFieldEnd()
17366 
    iprot.readStructEnd()
17367 
 
17368 
  def write(self, oprot):
17369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17371 
      return
17372 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17373 
    if self.orderId is not None:
2616 chandransh 17374 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17375 
      oprot.writeI64(self.orderId)
17376 
      oprot.writeFieldEnd()
17377 
    oprot.writeFieldStop()
17378 
    oprot.writeStructEnd()
17379 
 
3431 rajveer 17380 
  def validate(self):
17381 
    return
17382 
 
17383 
 
2616 chandransh 17384 
  def __repr__(self):
17385 
    L = ['%s=%r' % (key, value)
17386 
      for key, value in self.__dict__.iteritems()]
17387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17388 
 
17389 
  def __eq__(self, other):
17390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17391 
 
17392 
  def __ne__(self, other):
17393 
    return not (self == other)
17394 
 
17395 
class reshipOrder_result:
17396 
  """
17397 
  Attributes:
17398 
   - success
17399 
   - ex
17400 
  """
17401 
 
17402 
  thrift_spec = (
17403 
    (0, TType.I64, 'success', None, None, ), # 0
17404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17405 
  )
17406 
 
17407 
  def __init__(self, success=None, ex=None,):
17408 
    self.success = success
17409 
    self.ex = ex
17410 
 
17411 
  def read(self, iprot):
17412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17414 
      return
17415 
    iprot.readStructBegin()
17416 
    while True:
17417 
      (fname, ftype, fid) = iprot.readFieldBegin()
17418 
      if ftype == TType.STOP:
17419 
        break
17420 
      if fid == 0:
17421 
        if ftype == TType.I64:
17422 
          self.success = iprot.readI64();
17423 
        else:
17424 
          iprot.skip(ftype)
17425 
      elif fid == 1:
17426 
        if ftype == TType.STRUCT:
17427 
          self.ex = TransactionServiceException()
17428 
          self.ex.read(iprot)
17429 
        else:
17430 
          iprot.skip(ftype)
17431 
      else:
17432 
        iprot.skip(ftype)
17433 
      iprot.readFieldEnd()
17434 
    iprot.readStructEnd()
17435 
 
17436 
  def write(self, oprot):
17437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17439 
      return
17440 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17441 
    if self.success is not None:
2616 chandransh 17442 
      oprot.writeFieldBegin('success', TType.I64, 0)
17443 
      oprot.writeI64(self.success)
17444 
      oprot.writeFieldEnd()
3431 rajveer 17445 
    if self.ex is not None:
2616 chandransh 17446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17447 
      self.ex.write(oprot)
17448 
      oprot.writeFieldEnd()
17449 
    oprot.writeFieldStop()
17450 
    oprot.writeStructEnd()
17451 
 
3431 rajveer 17452 
  def validate(self):
17453 
    return
17454 
 
17455 
 
2616 chandransh 17456 
  def __repr__(self):
17457 
    L = ['%s=%r' % (key, value)
17458 
      for key, value in self.__dict__.iteritems()]
17459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17460 
 
17461 
  def __eq__(self, other):
17462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17463 
 
17464 
  def __ne__(self, other):
17465 
    return not (self == other)
17466 
 
17467 
class refundOrder_args:
17468 
  """
17469 
  Attributes:
17470 
   - orderId
3226 chandransh 17471 
   - refundedBy
17472 
   - reason
2616 chandransh 17473 
  """
17474 
 
17475 
  thrift_spec = (
17476 
    None, # 0
17477 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17478 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17479 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17480 
  )
17481 
 
3226 chandransh 17482 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17483 
    self.orderId = orderId
3226 chandransh 17484 
    self.refundedBy = refundedBy
17485 
    self.reason = reason
2616 chandransh 17486 
 
17487 
  def read(self, iprot):
17488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17490 
      return
17491 
    iprot.readStructBegin()
17492 
    while True:
17493 
      (fname, ftype, fid) = iprot.readFieldBegin()
17494 
      if ftype == TType.STOP:
17495 
        break
17496 
      if fid == 1:
17497 
        if ftype == TType.I64:
17498 
          self.orderId = iprot.readI64();
17499 
        else:
17500 
          iprot.skip(ftype)
3226 chandransh 17501 
      elif fid == 2:
17502 
        if ftype == TType.STRING:
17503 
          self.refundedBy = iprot.readString();
17504 
        else:
17505 
          iprot.skip(ftype)
17506 
      elif fid == 3:
17507 
        if ftype == TType.STRING:
17508 
          self.reason = iprot.readString();
17509 
        else:
17510 
          iprot.skip(ftype)
2616 chandransh 17511 
      else:
17512 
        iprot.skip(ftype)
17513 
      iprot.readFieldEnd()
17514 
    iprot.readStructEnd()
17515 
 
17516 
  def write(self, oprot):
17517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17519 
      return
17520 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17521 
    if self.orderId is not None:
2616 chandransh 17522 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17523 
      oprot.writeI64(self.orderId)
17524 
      oprot.writeFieldEnd()
3431 rajveer 17525 
    if self.refundedBy is not None:
3226 chandransh 17526 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17527 
      oprot.writeString(self.refundedBy)
17528 
      oprot.writeFieldEnd()
3431 rajveer 17529 
    if self.reason is not None:
3226 chandransh 17530 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17531 
      oprot.writeString(self.reason)
17532 
      oprot.writeFieldEnd()
2616 chandransh 17533 
    oprot.writeFieldStop()
17534 
    oprot.writeStructEnd()
17535 
 
3431 rajveer 17536 
  def validate(self):
17537 
    return
17538 
 
17539 
 
2616 chandransh 17540 
  def __repr__(self):
17541 
    L = ['%s=%r' % (key, value)
17542 
      for key, value in self.__dict__.iteritems()]
17543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17544 
 
17545 
  def __eq__(self, other):
17546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17547 
 
17548 
  def __ne__(self, other):
17549 
    return not (self == other)
17550 
 
17551 
class refundOrder_result:
17552 
  """
17553 
  Attributes:
17554 
   - success
17555 
   - ex
17556 
  """
17557 
 
17558 
  thrift_spec = (
17559 
    (0, TType.BOOL, 'success', None, None, ), # 0
17560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17561 
  )
17562 
 
17563 
  def __init__(self, success=None, ex=None,):
17564 
    self.success = success
17565 
    self.ex = ex
17566 
 
17567 
  def read(self, iprot):
17568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17570 
      return
17571 
    iprot.readStructBegin()
17572 
    while True:
17573 
      (fname, ftype, fid) = iprot.readFieldBegin()
17574 
      if ftype == TType.STOP:
17575 
        break
17576 
      if fid == 0:
17577 
        if ftype == TType.BOOL:
17578 
          self.success = iprot.readBool();
17579 
        else:
17580 
          iprot.skip(ftype)
17581 
      elif fid == 1:
17582 
        if ftype == TType.STRUCT:
17583 
          self.ex = TransactionServiceException()
17584 
          self.ex.read(iprot)
17585 
        else:
17586 
          iprot.skip(ftype)
17587 
      else:
17588 
        iprot.skip(ftype)
17589 
      iprot.readFieldEnd()
17590 
    iprot.readStructEnd()
17591 
 
17592 
  def write(self, oprot):
17593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17595 
      return
17596 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17597 
    if self.success is not None:
2616 chandransh 17598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17599 
      oprot.writeBool(self.success)
17600 
      oprot.writeFieldEnd()
3431 rajveer 17601 
    if self.ex is not None:
2616 chandransh 17602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17603 
      self.ex.write(oprot)
17604 
      oprot.writeFieldEnd()
17605 
    oprot.writeFieldStop()
17606 
    oprot.writeStructEnd()
17607 
 
3431 rajveer 17608 
  def validate(self):
17609 
    return
17610 
 
17611 
 
2616 chandransh 17612 
  def __repr__(self):
17613 
    L = ['%s=%r' % (key, value)
17614 
      for key, value in self.__dict__.iteritems()]
17615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17616 
 
17617 
  def __eq__(self, other):
17618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17619 
 
17620 
  def __ne__(self, other):
17621 
    return not (self == other)
17622 
 
2690 chandransh 17623 
class getReturnOrders_args:
17624 
  """
17625 
  Attributes:
17626 
   - warehouseId
17627 
   - fromDate
17628 
   - toDate
17629 
  """
2616 chandransh 17630 
 
2690 chandransh 17631 
  thrift_spec = (
17632 
    None, # 0
17633 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17634 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17635 
    (3, TType.I64, 'toDate', None, None, ), # 3
17636 
  )
17637 
 
17638 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17639 
    self.warehouseId = warehouseId
17640 
    self.fromDate = fromDate
17641 
    self.toDate = toDate
17642 
 
17643 
  def read(self, iprot):
17644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17646 
      return
17647 
    iprot.readStructBegin()
17648 
    while True:
17649 
      (fname, ftype, fid) = iprot.readFieldBegin()
17650 
      if ftype == TType.STOP:
17651 
        break
17652 
      if fid == 1:
17653 
        if ftype == TType.I64:
17654 
          self.warehouseId = iprot.readI64();
17655 
        else:
17656 
          iprot.skip(ftype)
17657 
      elif fid == 2:
17658 
        if ftype == TType.I64:
17659 
          self.fromDate = iprot.readI64();
17660 
        else:
17661 
          iprot.skip(ftype)
17662 
      elif fid == 3:
17663 
        if ftype == TType.I64:
17664 
          self.toDate = iprot.readI64();
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17677 
    if self.warehouseId is not None:
2690 chandransh 17678 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17679 
      oprot.writeI64(self.warehouseId)
17680 
      oprot.writeFieldEnd()
3431 rajveer 17681 
    if self.fromDate is not None:
2690 chandransh 17682 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17683 
      oprot.writeI64(self.fromDate)
17684 
      oprot.writeFieldEnd()
3431 rajveer 17685 
    if self.toDate is not None:
2690 chandransh 17686 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17687 
      oprot.writeI64(self.toDate)
17688 
      oprot.writeFieldEnd()
17689 
    oprot.writeFieldStop()
17690 
    oprot.writeStructEnd()
17691 
 
3431 rajveer 17692 
  def validate(self):
17693 
    return
17694 
 
17695 
 
2690 chandransh 17696 
  def __repr__(self):
17697 
    L = ['%s=%r' % (key, value)
17698 
      for key, value in self.__dict__.iteritems()]
17699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17700 
 
17701 
  def __eq__(self, other):
17702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17703 
 
17704 
  def __ne__(self, other):
17705 
    return not (self == other)
17706 
 
17707 
class getReturnOrders_result:
17708 
  """
17709 
  Attributes:
17710 
   - success
17711 
  """
17712 
 
17713 
  thrift_spec = (
17714 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17715 
  )
17716 
 
17717 
  def __init__(self, success=None,):
17718 
    self.success = success
17719 
 
17720 
  def read(self, iprot):
17721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17723 
      return
17724 
    iprot.readStructBegin()
17725 
    while True:
17726 
      (fname, ftype, fid) = iprot.readFieldBegin()
17727 
      if ftype == TType.STOP:
17728 
        break
17729 
      if fid == 0:
17730 
        if ftype == TType.LIST:
17731 
          self.success = []
6000 mandeep.dh 17732 
          (_etype406, _size403) = iprot.readListBegin()
17733 
          for _i407 in xrange(_size403):
17734 
            _elem408 = ReturnOrder()
17735 
            _elem408.read(iprot)
17736 
            self.success.append(_elem408)
2690 chandransh 17737 
          iprot.readListEnd()
17738 
        else:
17739 
          iprot.skip(ftype)
17740 
      else:
17741 
        iprot.skip(ftype)
17742 
      iprot.readFieldEnd()
17743 
    iprot.readStructEnd()
17744 
 
17745 
  def write(self, oprot):
17746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17748 
      return
17749 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17750 
    if self.success is not None:
2690 chandransh 17751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 17753 
      for iter409 in self.success:
17754 
        iter409.write(oprot)
2690 chandransh 17755 
      oprot.writeListEnd()
17756 
      oprot.writeFieldEnd()
17757 
    oprot.writeFieldStop()
17758 
    oprot.writeStructEnd()
17759 
 
3431 rajveer 17760 
  def validate(self):
17761 
    return
17762 
 
17763 
 
2690 chandransh 17764 
  def __repr__(self):
17765 
    L = ['%s=%r' % (key, value)
17766 
      for key, value in self.__dict__.iteritems()]
17767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17768 
 
17769 
  def __eq__(self, other):
17770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17771 
 
17772 
  def __ne__(self, other):
17773 
    return not (self == other)
17774 
 
5481 phani.kuma 17775 
class getAllReturnOrders_args:
17776 
  """
17777 
  Attributes:
17778 
   - onlyNotProcessed
17779 
   - fromDate
17780 
   - toDate
17781 
  """
17782 
 
17783 
  thrift_spec = (
17784 
    None, # 0
17785 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17786 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17787 
    (3, TType.I64, 'toDate', None, None, ), # 3
17788 
  )
17789 
 
17790 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17791 
    self.onlyNotProcessed = onlyNotProcessed
17792 
    self.fromDate = fromDate
17793 
    self.toDate = toDate
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      if fid == 1:
17805 
        if ftype == TType.BOOL:
17806 
          self.onlyNotProcessed = iprot.readBool();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      elif fid == 2:
17810 
        if ftype == TType.I64:
17811 
          self.fromDate = iprot.readI64();
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      elif fid == 3:
17815 
        if ftype == TType.I64:
17816 
          self.toDate = iprot.readI64();
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('getAllReturnOrders_args')
17829 
    if self.onlyNotProcessed is not None:
17830 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17831 
      oprot.writeBool(self.onlyNotProcessed)
17832 
      oprot.writeFieldEnd()
17833 
    if self.fromDate is not None:
17834 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17835 
      oprot.writeI64(self.fromDate)
17836 
      oprot.writeFieldEnd()
17837 
    if self.toDate is not None:
17838 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17839 
      oprot.writeI64(self.toDate)
17840 
      oprot.writeFieldEnd()
17841 
    oprot.writeFieldStop()
17842 
    oprot.writeStructEnd()
17843 
 
17844 
  def validate(self):
17845 
    return
17846 
 
17847 
 
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 getAllReturnOrders_result:
17860 
  """
17861 
  Attributes:
17862 
   - success
17863 
  """
17864 
 
17865 
  thrift_spec = (
17866 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17867 
  )
17868 
 
17869 
  def __init__(self, success=None,):
17870 
    self.success = success
17871 
 
17872 
  def read(self, iprot):
17873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17875 
      return
17876 
    iprot.readStructBegin()
17877 
    while True:
17878 
      (fname, ftype, fid) = iprot.readFieldBegin()
17879 
      if ftype == TType.STOP:
17880 
        break
17881 
      if fid == 0:
17882 
        if ftype == TType.LIST:
17883 
          self.success = []
6000 mandeep.dh 17884 
          (_etype413, _size410) = iprot.readListBegin()
17885 
          for _i414 in xrange(_size410):
17886 
            _elem415 = ReturnOrder()
17887 
            _elem415.read(iprot)
17888 
            self.success.append(_elem415)
5481 phani.kuma 17889 
          iprot.readListEnd()
17890 
        else:
17891 
          iprot.skip(ftype)
17892 
      else:
17893 
        iprot.skip(ftype)
17894 
      iprot.readFieldEnd()
17895 
    iprot.readStructEnd()
17896 
 
17897 
  def write(self, oprot):
17898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17900 
      return
17901 
    oprot.writeStructBegin('getAllReturnOrders_result')
17902 
    if self.success is not None:
17903 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17904 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 17905 
      for iter416 in self.success:
17906 
        iter416.write(oprot)
5481 phani.kuma 17907 
      oprot.writeListEnd()
17908 
      oprot.writeFieldEnd()
17909 
    oprot.writeFieldStop()
17910 
    oprot.writeStructEnd()
17911 
 
17912 
  def validate(self):
17913 
    return
17914 
 
17915 
 
17916 
  def __repr__(self):
17917 
    L = ['%s=%r' % (key, value)
17918 
      for key, value in self.__dict__.iteritems()]
17919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17920 
 
17921 
  def __eq__(self, other):
17922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17923 
 
17924 
  def __ne__(self, other):
17925 
    return not (self == other)
17926 
 
2700 chandransh 17927 
class getReturnOrder_args:
17928 
  """
17929 
  Attributes:
17930 
   - id
17931 
  """
17932 
 
17933 
  thrift_spec = (
17934 
    None, # 0
17935 
    (1, TType.I64, 'id', None, None, ), # 1
17936 
  )
17937 
 
17938 
  def __init__(self, id=None,):
17939 
    self.id = id
17940 
 
17941 
  def read(self, iprot):
17942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17944 
      return
17945 
    iprot.readStructBegin()
17946 
    while True:
17947 
      (fname, ftype, fid) = iprot.readFieldBegin()
17948 
      if ftype == TType.STOP:
17949 
        break
17950 
      if fid == 1:
17951 
        if ftype == TType.I64:
17952 
          self.id = iprot.readI64();
17953 
        else:
17954 
          iprot.skip(ftype)
17955 
      else:
17956 
        iprot.skip(ftype)
17957 
      iprot.readFieldEnd()
17958 
    iprot.readStructEnd()
17959 
 
17960 
  def write(self, oprot):
17961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17963 
      return
17964 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17965 
    if self.id is not None:
2700 chandransh 17966 
      oprot.writeFieldBegin('id', TType.I64, 1)
17967 
      oprot.writeI64(self.id)
17968 
      oprot.writeFieldEnd()
17969 
    oprot.writeFieldStop()
17970 
    oprot.writeStructEnd()
17971 
 
3431 rajveer 17972 
  def validate(self):
17973 
    return
17974 
 
17975 
 
2700 chandransh 17976 
  def __repr__(self):
17977 
    L = ['%s=%r' % (key, value)
17978 
      for key, value in self.__dict__.iteritems()]
17979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17980 
 
17981 
  def __eq__(self, other):
17982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17983 
 
17984 
  def __ne__(self, other):
17985 
    return not (self == other)
17986 
 
17987 
class getReturnOrder_result:
17988 
  """
17989 
  Attributes:
17990 
   - success
17991 
   - ex
17992 
  """
17993 
 
17994 
  thrift_spec = (
17995 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17997 
  )
17998 
 
17999 
  def __init__(self, success=None, ex=None,):
18000 
    self.success = success
18001 
    self.ex = ex
18002 
 
18003 
  def read(self, iprot):
18004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18006 
      return
18007 
    iprot.readStructBegin()
18008 
    while True:
18009 
      (fname, ftype, fid) = iprot.readFieldBegin()
18010 
      if ftype == TType.STOP:
18011 
        break
18012 
      if fid == 0:
18013 
        if ftype == TType.STRUCT:
18014 
          self.success = ReturnOrder()
18015 
          self.success.read(iprot)
18016 
        else:
18017 
          iprot.skip(ftype)
18018 
      elif fid == 1:
18019 
        if ftype == TType.STRUCT:
18020 
          self.ex = TransactionServiceException()
18021 
          self.ex.read(iprot)
18022 
        else:
18023 
          iprot.skip(ftype)
18024 
      else:
18025 
        iprot.skip(ftype)
18026 
      iprot.readFieldEnd()
18027 
    iprot.readStructEnd()
18028 
 
18029 
  def write(self, oprot):
18030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18032 
      return
18033 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18034 
    if self.success is not None:
2700 chandransh 18035 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18036 
      self.success.write(oprot)
18037 
      oprot.writeFieldEnd()
3431 rajveer 18038 
    if self.ex is not None:
2700 chandransh 18039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18040 
      self.ex.write(oprot)
18041 
      oprot.writeFieldEnd()
18042 
    oprot.writeFieldStop()
18043 
    oprot.writeStructEnd()
18044 
 
3431 rajveer 18045 
  def validate(self):
18046 
    return
18047 
 
18048 
 
2700 chandransh 18049 
  def __repr__(self):
18050 
    L = ['%s=%r' % (key, value)
18051 
      for key, value in self.__dict__.iteritems()]
18052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18053 
 
18054 
  def __eq__(self, other):
18055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18056 
 
18057 
  def __ne__(self, other):
18058 
    return not (self == other)
18059 
 
2690 chandransh 18060 
class processReturn_args:
18061 
  """
18062 
  Attributes:
18063 
   - returnOrderId
18064 
  """
18065 
 
18066 
  thrift_spec = (
18067 
    None, # 0
18068 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18069 
  )
18070 
 
18071 
  def __init__(self, returnOrderId=None,):
18072 
    self.returnOrderId = returnOrderId
18073 
 
18074 
  def read(self, iprot):
18075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18077 
      return
18078 
    iprot.readStructBegin()
18079 
    while True:
18080 
      (fname, ftype, fid) = iprot.readFieldBegin()
18081 
      if ftype == TType.STOP:
18082 
        break
18083 
      if fid == 1:
18084 
        if ftype == TType.I64:
18085 
          self.returnOrderId = iprot.readI64();
18086 
        else:
18087 
          iprot.skip(ftype)
18088 
      else:
18089 
        iprot.skip(ftype)
18090 
      iprot.readFieldEnd()
18091 
    iprot.readStructEnd()
18092 
 
18093 
  def write(self, oprot):
18094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18096 
      return
18097 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18098 
    if self.returnOrderId is not None:
2690 chandransh 18099 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18100 
      oprot.writeI64(self.returnOrderId)
18101 
      oprot.writeFieldEnd()
18102 
    oprot.writeFieldStop()
18103 
    oprot.writeStructEnd()
18104 
 
3431 rajveer 18105 
  def validate(self):
18106 
    return
18107 
 
18108 
 
2690 chandransh 18109 
  def __repr__(self):
18110 
    L = ['%s=%r' % (key, value)
18111 
      for key, value in self.__dict__.iteritems()]
18112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18113 
 
18114 
  def __eq__(self, other):
18115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18116 
 
18117 
  def __ne__(self, other):
18118 
    return not (self == other)
18119 
 
18120 
class processReturn_result:
18121 
  """
18122 
  Attributes:
18123 
   - ex
18124 
  """
18125 
 
18126 
  thrift_spec = (
18127 
    None, # 0
18128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18129 
  )
18130 
 
18131 
  def __init__(self, ex=None,):
18132 
    self.ex = ex
18133 
 
18134 
  def read(self, iprot):
18135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18137 
      return
18138 
    iprot.readStructBegin()
18139 
    while True:
18140 
      (fname, ftype, fid) = iprot.readFieldBegin()
18141 
      if ftype == TType.STOP:
18142 
        break
18143 
      if fid == 1:
18144 
        if ftype == TType.STRUCT:
18145 
          self.ex = TransactionServiceException()
18146 
          self.ex.read(iprot)
18147 
        else:
18148 
          iprot.skip(ftype)
18149 
      else:
18150 
        iprot.skip(ftype)
18151 
      iprot.readFieldEnd()
18152 
    iprot.readStructEnd()
18153 
 
18154 
  def write(self, oprot):
18155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18157 
      return
18158 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18159 
    if self.ex is not None:
2690 chandransh 18160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18161 
      self.ex.write(oprot)
18162 
      oprot.writeFieldEnd()
18163 
    oprot.writeFieldStop()
18164 
    oprot.writeStructEnd()
18165 
 
3431 rajveer 18166 
  def validate(self):
18167 
    return
18168 
 
18169 
 
2690 chandransh 18170 
  def __repr__(self):
18171 
    L = ['%s=%r' % (key, value)
18172 
      for key, value in self.__dict__.iteritems()]
18173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18174 
 
18175 
  def __eq__(self, other):
18176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18177 
 
18178 
  def __ne__(self, other):
18179 
    return not (self == other)
18180 
 
3451 chandransh 18181 
class updateWeight_args:
18182 
  """
18183 
  Attributes:
18184 
   - orderId
18185 
   - weight
18186 
  """
18187 
 
18188 
  thrift_spec = (
18189 
    None, # 0
18190 
    (1, TType.I64, 'orderId', None, None, ), # 1
18191 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18192 
  )
18193 
 
18194 
  def __init__(self, orderId=None, weight=None,):
18195 
    self.orderId = orderId
18196 
    self.weight = weight
18197 
 
18198 
  def read(self, iprot):
18199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18201 
      return
18202 
    iprot.readStructBegin()
18203 
    while True:
18204 
      (fname, ftype, fid) = iprot.readFieldBegin()
18205 
      if ftype == TType.STOP:
18206 
        break
18207 
      if fid == 1:
18208 
        if ftype == TType.I64:
18209 
          self.orderId = iprot.readI64();
18210 
        else:
18211 
          iprot.skip(ftype)
18212 
      elif fid == 2:
18213 
        if ftype == TType.DOUBLE:
18214 
          self.weight = iprot.readDouble();
18215 
        else:
18216 
          iprot.skip(ftype)
18217 
      else:
18218 
        iprot.skip(ftype)
18219 
      iprot.readFieldEnd()
18220 
    iprot.readStructEnd()
18221 
 
18222 
  def write(self, oprot):
18223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18225 
      return
18226 
    oprot.writeStructBegin('updateWeight_args')
18227 
    if self.orderId is not None:
18228 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18229 
      oprot.writeI64(self.orderId)
18230 
      oprot.writeFieldEnd()
18231 
    if self.weight is not None:
18232 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18233 
      oprot.writeDouble(self.weight)
18234 
      oprot.writeFieldEnd()
18235 
    oprot.writeFieldStop()
18236 
    oprot.writeStructEnd()
18237 
 
18238 
  def validate(self):
18239 
    return
18240 
 
18241 
 
18242 
  def __repr__(self):
18243 
    L = ['%s=%r' % (key, value)
18244 
      for key, value in self.__dict__.iteritems()]
18245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18246 
 
18247 
  def __eq__(self, other):
18248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18249 
 
18250 
  def __ne__(self, other):
18251 
    return not (self == other)
18252 
 
18253 
class updateWeight_result:
18254 
  """
18255 
  Attributes:
18256 
   - success
18257 
   - ex
18258 
  """
18259 
 
18260 
  thrift_spec = (
18261 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18263 
  )
18264 
 
18265 
  def __init__(self, success=None, ex=None,):
18266 
    self.success = success
18267 
    self.ex = ex
18268 
 
18269 
  def read(self, iprot):
18270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18272 
      return
18273 
    iprot.readStructBegin()
18274 
    while True:
18275 
      (fname, ftype, fid) = iprot.readFieldBegin()
18276 
      if ftype == TType.STOP:
18277 
        break
18278 
      if fid == 0:
18279 
        if ftype == TType.STRUCT:
18280 
          self.success = Order()
18281 
          self.success.read(iprot)
18282 
        else:
18283 
          iprot.skip(ftype)
18284 
      elif fid == 1:
18285 
        if ftype == TType.STRUCT:
18286 
          self.ex = TransactionServiceException()
18287 
          self.ex.read(iprot)
18288 
        else:
18289 
          iprot.skip(ftype)
18290 
      else:
18291 
        iprot.skip(ftype)
18292 
      iprot.readFieldEnd()
18293 
    iprot.readStructEnd()
18294 
 
18295 
  def write(self, oprot):
18296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18298 
      return
18299 
    oprot.writeStructBegin('updateWeight_result')
18300 
    if self.success is not None:
18301 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18302 
      self.success.write(oprot)
18303 
      oprot.writeFieldEnd()
18304 
    if self.ex is not None:
18305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18306 
      self.ex.write(oprot)
18307 
      oprot.writeFieldEnd()
18308 
    oprot.writeFieldStop()
18309 
    oprot.writeStructEnd()
18310 
 
18311 
  def validate(self):
18312 
    return
18313 
 
18314 
 
18315 
  def __repr__(self):
18316 
    L = ['%s=%r' % (key, value)
18317 
      for key, value in self.__dict__.iteritems()]
18318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18319 
 
18320 
  def __eq__(self, other):
18321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18322 
 
18323 
  def __ne__(self, other):
18324 
    return not (self == other)
3469 chandransh 18325 
 
18326 
class changeItem_args:
18327 
  """
18328 
  Attributes:
18329 
   - orderId
18330 
   - itemId
18331 
  """
18332 
 
18333 
  thrift_spec = (
18334 
    None, # 0
18335 
    (1, TType.I64, 'orderId', None, None, ), # 1
18336 
    (2, TType.I64, 'itemId', None, None, ), # 2
18337 
  )
18338 
 
18339 
  def __init__(self, orderId=None, itemId=None,):
18340 
    self.orderId = orderId
18341 
    self.itemId = itemId
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 1:
18353 
        if ftype == TType.I64:
18354 
          self.orderId = iprot.readI64();
18355 
        else:
18356 
          iprot.skip(ftype)
18357 
      elif fid == 2:
18358 
        if ftype == TType.I64:
18359 
          self.itemId = iprot.readI64();
18360 
        else:
18361 
          iprot.skip(ftype)
18362 
      else:
18363 
        iprot.skip(ftype)
18364 
      iprot.readFieldEnd()
18365 
    iprot.readStructEnd()
18366 
 
18367 
  def write(self, oprot):
18368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18370 
      return
18371 
    oprot.writeStructBegin('changeItem_args')
18372 
    if self.orderId is not None:
18373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18374 
      oprot.writeI64(self.orderId)
18375 
      oprot.writeFieldEnd()
18376 
    if self.itemId is not None:
18377 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18378 
      oprot.writeI64(self.itemId)
18379 
      oprot.writeFieldEnd()
18380 
    oprot.writeFieldStop()
18381 
    oprot.writeStructEnd()
18382 
 
18383 
  def validate(self):
18384 
    return
18385 
 
18386 
 
18387 
  def __repr__(self):
18388 
    L = ['%s=%r' % (key, value)
18389 
      for key, value in self.__dict__.iteritems()]
18390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18391 
 
18392 
  def __eq__(self, other):
18393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18394 
 
18395 
  def __ne__(self, other):
18396 
    return not (self == other)
18397 
 
18398 
class changeItem_result:
18399 
  """
18400 
  Attributes:
18401 
   - success
18402 
   - ex
18403 
  """
18404 
 
18405 
  thrift_spec = (
18406 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18407 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18408 
  )
18409 
 
18410 
  def __init__(self, success=None, ex=None,):
18411 
    self.success = success
18412 
    self.ex = ex
18413 
 
18414 
  def read(self, iprot):
18415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18417 
      return
18418 
    iprot.readStructBegin()
18419 
    while True:
18420 
      (fname, ftype, fid) = iprot.readFieldBegin()
18421 
      if ftype == TType.STOP:
18422 
        break
18423 
      if fid == 0:
18424 
        if ftype == TType.STRUCT:
18425 
          self.success = Order()
18426 
          self.success.read(iprot)
18427 
        else:
18428 
          iprot.skip(ftype)
18429 
      elif fid == 1:
18430 
        if ftype == TType.STRUCT:
18431 
          self.ex = TransactionServiceException()
18432 
          self.ex.read(iprot)
18433 
        else:
18434 
          iprot.skip(ftype)
18435 
      else:
18436 
        iprot.skip(ftype)
18437 
      iprot.readFieldEnd()
18438 
    iprot.readStructEnd()
18439 
 
18440 
  def write(self, oprot):
18441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18443 
      return
18444 
    oprot.writeStructBegin('changeItem_result')
18445 
    if self.success is not None:
18446 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18447 
      self.success.write(oprot)
18448 
      oprot.writeFieldEnd()
18449 
    if self.ex is not None:
18450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18451 
      self.ex.write(oprot)
18452 
      oprot.writeFieldEnd()
18453 
    oprot.writeFieldStop()
18454 
    oprot.writeStructEnd()
18455 
 
18456 
  def validate(self):
18457 
    return
18458 
 
18459 
 
18460 
  def __repr__(self):
18461 
    L = ['%s=%r' % (key, value)
18462 
      for key, value in self.__dict__.iteritems()]
18463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18464 
 
18465 
  def __eq__(self, other):
18466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18467 
 
18468 
  def __ne__(self, other):
18469 
    return not (self == other)
18470 
 
18471 
class shiftToWarehouse_args:
18472 
  """
18473 
  Attributes:
18474 
   - orderId
18475 
   - warehouseId
18476 
  """
18477 
 
18478 
  thrift_spec = (
18479 
    None, # 0
18480 
    (1, TType.I64, 'orderId', None, None, ), # 1
18481 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18482 
  )
18483 
 
18484 
  def __init__(self, orderId=None, warehouseId=None,):
18485 
    self.orderId = orderId
18486 
    self.warehouseId = warehouseId
18487 
 
18488 
  def read(self, iprot):
18489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18491 
      return
18492 
    iprot.readStructBegin()
18493 
    while True:
18494 
      (fname, ftype, fid) = iprot.readFieldBegin()
18495 
      if ftype == TType.STOP:
18496 
        break
18497 
      if fid == 1:
18498 
        if ftype == TType.I64:
18499 
          self.orderId = iprot.readI64();
18500 
        else:
18501 
          iprot.skip(ftype)
18502 
      elif fid == 2:
18503 
        if ftype == TType.I64:
18504 
          self.warehouseId = iprot.readI64();
18505 
        else:
18506 
          iprot.skip(ftype)
18507 
      else:
18508 
        iprot.skip(ftype)
18509 
      iprot.readFieldEnd()
18510 
    iprot.readStructEnd()
18511 
 
18512 
  def write(self, oprot):
18513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18515 
      return
18516 
    oprot.writeStructBegin('shiftToWarehouse_args')
18517 
    if self.orderId is not None:
18518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18519 
      oprot.writeI64(self.orderId)
18520 
      oprot.writeFieldEnd()
18521 
    if self.warehouseId is not None:
18522 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18523 
      oprot.writeI64(self.warehouseId)
18524 
      oprot.writeFieldEnd()
18525 
    oprot.writeFieldStop()
18526 
    oprot.writeStructEnd()
18527 
 
18528 
  def validate(self):
18529 
    return
18530 
 
18531 
 
18532 
  def __repr__(self):
18533 
    L = ['%s=%r' % (key, value)
18534 
      for key, value in self.__dict__.iteritems()]
18535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18536 
 
18537 
  def __eq__(self, other):
18538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18539 
 
18540 
  def __ne__(self, other):
18541 
    return not (self == other)
18542 
 
18543 
class shiftToWarehouse_result:
18544 
  """
18545 
  Attributes:
18546 
   - success
18547 
   - ex
18548 
  """
18549 
 
18550 
  thrift_spec = (
18551 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18553 
  )
18554 
 
18555 
  def __init__(self, success=None, ex=None,):
18556 
    self.success = success
18557 
    self.ex = ex
18558 
 
18559 
  def read(self, iprot):
18560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18562 
      return
18563 
    iprot.readStructBegin()
18564 
    while True:
18565 
      (fname, ftype, fid) = iprot.readFieldBegin()
18566 
      if ftype == TType.STOP:
18567 
        break
18568 
      if fid == 0:
18569 
        if ftype == TType.STRUCT:
18570 
          self.success = Order()
18571 
          self.success.read(iprot)
18572 
        else:
18573 
          iprot.skip(ftype)
18574 
      elif fid == 1:
18575 
        if ftype == TType.STRUCT:
18576 
          self.ex = TransactionServiceException()
18577 
          self.ex.read(iprot)
18578 
        else:
18579 
          iprot.skip(ftype)
18580 
      else:
18581 
        iprot.skip(ftype)
18582 
      iprot.readFieldEnd()
18583 
    iprot.readStructEnd()
18584 
 
18585 
  def write(self, oprot):
18586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18588 
      return
18589 
    oprot.writeStructBegin('shiftToWarehouse_result')
18590 
    if self.success is not None:
18591 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18592 
      self.success.write(oprot)
18593 
      oprot.writeFieldEnd()
18594 
    if self.ex is not None:
18595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18596 
      self.ex.write(oprot)
18597 
      oprot.writeFieldEnd()
18598 
    oprot.writeFieldStop()
18599 
    oprot.writeStructEnd()
18600 
 
18601 
  def validate(self):
18602 
    return
18603 
 
18604 
 
18605 
  def __repr__(self):
18606 
    L = ['%s=%r' % (key, value)
18607 
      for key, value in self.__dict__.iteritems()]
18608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18609 
 
18610 
  def __eq__(self, other):
18611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18612 
 
18613 
  def __ne__(self, other):
18614 
    return not (self == other)
3553 chandransh 18615 
 
18616 
class addDelayReason_args:
18617 
  """
18618 
  Attributes:
18619 
   - orderId
18620 
   - delayReason
3986 chandransh 18621 
   - furtherDelay
4647 rajveer 18622 
   - delayReasonText
3553 chandransh 18623 
  """
18624 
 
18625 
  thrift_spec = (
18626 
    None, # 0
18627 
    (1, TType.I64, 'orderId', None, None, ), # 1
18628 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18629 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18630 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18631 
  )
18632 
 
4647 rajveer 18633 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18634 
    self.orderId = orderId
18635 
    self.delayReason = delayReason
3986 chandransh 18636 
    self.furtherDelay = furtherDelay
4647 rajveer 18637 
    self.delayReasonText = delayReasonText
3553 chandransh 18638 
 
18639 
  def read(self, iprot):
18640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18642 
      return
18643 
    iprot.readStructBegin()
18644 
    while True:
18645 
      (fname, ftype, fid) = iprot.readFieldBegin()
18646 
      if ftype == TType.STOP:
18647 
        break
18648 
      if fid == 1:
18649 
        if ftype == TType.I64:
18650 
          self.orderId = iprot.readI64();
18651 
        else:
18652 
          iprot.skip(ftype)
18653 
      elif fid == 2:
18654 
        if ftype == TType.I32:
18655 
          self.delayReason = iprot.readI32();
18656 
        else:
18657 
          iprot.skip(ftype)
3986 chandransh 18658 
      elif fid == 3:
18659 
        if ftype == TType.I64:
18660 
          self.furtherDelay = iprot.readI64();
18661 
        else:
18662 
          iprot.skip(ftype)
4647 rajveer 18663 
      elif fid == 4:
18664 
        if ftype == TType.STRING:
18665 
          self.delayReasonText = iprot.readString();
18666 
        else:
18667 
          iprot.skip(ftype)
3553 chandransh 18668 
      else:
18669 
        iprot.skip(ftype)
18670 
      iprot.readFieldEnd()
18671 
    iprot.readStructEnd()
18672 
 
18673 
  def write(self, oprot):
18674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18676 
      return
18677 
    oprot.writeStructBegin('addDelayReason_args')
18678 
    if self.orderId is not None:
18679 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18680 
      oprot.writeI64(self.orderId)
18681 
      oprot.writeFieldEnd()
18682 
    if self.delayReason is not None:
18683 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18684 
      oprot.writeI32(self.delayReason)
18685 
      oprot.writeFieldEnd()
3986 chandransh 18686 
    if self.furtherDelay is not None:
18687 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18688 
      oprot.writeI64(self.furtherDelay)
18689 
      oprot.writeFieldEnd()
4647 rajveer 18690 
    if self.delayReasonText is not None:
18691 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18692 
      oprot.writeString(self.delayReasonText)
18693 
      oprot.writeFieldEnd()
3553 chandransh 18694 
    oprot.writeFieldStop()
18695 
    oprot.writeStructEnd()
18696 
 
18697 
  def validate(self):
18698 
    return
18699 
 
18700 
 
18701 
  def __repr__(self):
18702 
    L = ['%s=%r' % (key, value)
18703 
      for key, value in self.__dict__.iteritems()]
18704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18705 
 
18706 
  def __eq__(self, other):
18707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18708 
 
18709 
  def __ne__(self, other):
18710 
    return not (self == other)
18711 
 
18712 
class addDelayReason_result:
18713 
  """
18714 
  Attributes:
18715 
   - success
18716 
   - ex
18717 
  """
18718 
 
18719 
  thrift_spec = (
18720 
    (0, TType.BOOL, 'success', None, None, ), # 0
18721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18722 
  )
18723 
 
18724 
  def __init__(self, success=None, ex=None,):
18725 
    self.success = success
18726 
    self.ex = ex
18727 
 
18728 
  def read(self, iprot):
18729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18731 
      return
18732 
    iprot.readStructBegin()
18733 
    while True:
18734 
      (fname, ftype, fid) = iprot.readFieldBegin()
18735 
      if ftype == TType.STOP:
18736 
        break
18737 
      if fid == 0:
18738 
        if ftype == TType.BOOL:
18739 
          self.success = iprot.readBool();
18740 
        else:
18741 
          iprot.skip(ftype)
18742 
      elif fid == 1:
18743 
        if ftype == TType.STRUCT:
18744 
          self.ex = TransactionServiceException()
18745 
          self.ex.read(iprot)
18746 
        else:
18747 
          iprot.skip(ftype)
18748 
      else:
18749 
        iprot.skip(ftype)
18750 
      iprot.readFieldEnd()
18751 
    iprot.readStructEnd()
18752 
 
18753 
  def write(self, oprot):
18754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18756 
      return
18757 
    oprot.writeStructBegin('addDelayReason_result')
18758 
    if self.success is not None:
18759 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18760 
      oprot.writeBool(self.success)
18761 
      oprot.writeFieldEnd()
18762 
    if self.ex is not None:
18763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18764 
      self.ex.write(oprot)
18765 
      oprot.writeFieldEnd()
18766 
    oprot.writeFieldStop()
18767 
    oprot.writeStructEnd()
18768 
 
18769 
  def validate(self):
18770 
    return
18771 
 
18772 
 
18773 
  def __repr__(self):
18774 
    L = ['%s=%r' % (key, value)
18775 
      for key, value in self.__dict__.iteritems()]
18776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18777 
 
18778 
  def __eq__(self, other):
18779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18780 
 
18781 
  def __ne__(self, other):
18782 
    return not (self == other)
3956 chandransh 18783 
 
18784 
class reconcileCodCollection_args:
18785 
  """
18786 
  Attributes:
18787 
   - collectedAmountMap
18788 
   - xferBy
18789 
   - xferTxnId
18790 
   - xferDate
18791 
  """
18792 
 
18793 
  thrift_spec = (
18794 
    None, # 0
18795 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18796 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18797 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18798 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18799 
  )
18800 
 
18801 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18802 
    self.collectedAmountMap = collectedAmountMap
18803 
    self.xferBy = xferBy
18804 
    self.xferTxnId = xferTxnId
18805 
    self.xferDate = xferDate
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.MAP:
18818 
          self.collectedAmountMap = {}
6000 mandeep.dh 18819 
          (_ktype418, _vtype419, _size417 ) = iprot.readMapBegin()
18820 
          for _i421 in xrange(_size417):
18821 
            _key422 = iprot.readString();
18822 
            _val423 = iprot.readDouble();
18823 
            self.collectedAmountMap[_key422] = _val423
3956 chandransh 18824 
          iprot.readMapEnd()
18825 
        else:
18826 
          iprot.skip(ftype)
18827 
      elif fid == 2:
18828 
        if ftype == TType.STRING:
18829 
          self.xferBy = iprot.readString();
18830 
        else:
18831 
          iprot.skip(ftype)
18832 
      elif fid == 3:
18833 
        if ftype == TType.STRING:
18834 
          self.xferTxnId = iprot.readString();
18835 
        else:
18836 
          iprot.skip(ftype)
18837 
      elif fid == 4:
18838 
        if ftype == TType.I64:
18839 
          self.xferDate = iprot.readI64();
18840 
        else:
18841 
          iprot.skip(ftype)
18842 
      else:
18843 
        iprot.skip(ftype)
18844 
      iprot.readFieldEnd()
18845 
    iprot.readStructEnd()
18846 
 
18847 
  def write(self, oprot):
18848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18850 
      return
18851 
    oprot.writeStructBegin('reconcileCodCollection_args')
18852 
    if self.collectedAmountMap is not None:
18853 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18854 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6000 mandeep.dh 18855 
      for kiter424,viter425 in self.collectedAmountMap.items():
18856 
        oprot.writeString(kiter424)
18857 
        oprot.writeDouble(viter425)
3956 chandransh 18858 
      oprot.writeMapEnd()
18859 
      oprot.writeFieldEnd()
18860 
    if self.xferBy is not None:
18861 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18862 
      oprot.writeString(self.xferBy)
18863 
      oprot.writeFieldEnd()
18864 
    if self.xferTxnId is not None:
18865 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18866 
      oprot.writeString(self.xferTxnId)
18867 
      oprot.writeFieldEnd()
18868 
    if self.xferDate is not None:
18869 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18870 
      oprot.writeI64(self.xferDate)
18871 
      oprot.writeFieldEnd()
18872 
    oprot.writeFieldStop()
18873 
    oprot.writeStructEnd()
18874 
 
18875 
  def validate(self):
18876 
    return
18877 
 
18878 
 
18879 
  def __repr__(self):
18880 
    L = ['%s=%r' % (key, value)
18881 
      for key, value in self.__dict__.iteritems()]
18882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18883 
 
18884 
  def __eq__(self, other):
18885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18886 
 
18887 
  def __ne__(self, other):
18888 
    return not (self == other)
18889 
 
18890 
class reconcileCodCollection_result:
18891 
  """
18892 
  Attributes:
18893 
   - success
18894 
   - ex
18895 
  """
18896 
 
18897 
  thrift_spec = (
18898 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18900 
  )
18901 
 
18902 
  def __init__(self, success=None, ex=None,):
18903 
    self.success = success
18904 
    self.ex = ex
18905 
 
18906 
  def read(self, iprot):
18907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18909 
      return
18910 
    iprot.readStructBegin()
18911 
    while True:
18912 
      (fname, ftype, fid) = iprot.readFieldBegin()
18913 
      if ftype == TType.STOP:
18914 
        break
18915 
      if fid == 0:
18916 
        if ftype == TType.MAP:
18917 
          self.success = {}
6000 mandeep.dh 18918 
          (_ktype427, _vtype428, _size426 ) = iprot.readMapBegin()
18919 
          for _i430 in xrange(_size426):
18920 
            _key431 = iprot.readString();
18921 
            _val432 = iprot.readString();
18922 
            self.success[_key431] = _val432
3956 chandransh 18923 
          iprot.readMapEnd()
18924 
        else:
18925 
          iprot.skip(ftype)
18926 
      elif fid == 1:
18927 
        if ftype == TType.STRUCT:
18928 
          self.ex = TransactionServiceException()
18929 
          self.ex.read(iprot)
18930 
        else:
18931 
          iprot.skip(ftype)
18932 
      else:
18933 
        iprot.skip(ftype)
18934 
      iprot.readFieldEnd()
18935 
    iprot.readStructEnd()
18936 
 
18937 
  def write(self, oprot):
18938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18940 
      return
18941 
    oprot.writeStructBegin('reconcileCodCollection_result')
18942 
    if self.success is not None:
18943 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18944 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6000 mandeep.dh 18945 
      for kiter433,viter434 in self.success.items():
18946 
        oprot.writeString(kiter433)
18947 
        oprot.writeString(viter434)
3956 chandransh 18948 
      oprot.writeMapEnd()
18949 
      oprot.writeFieldEnd()
18950 
    if self.ex is not None:
18951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18952 
      self.ex.write(oprot)
18953 
      oprot.writeFieldEnd()
18954 
    oprot.writeFieldStop()
18955 
    oprot.writeStructEnd()
18956 
 
18957 
  def validate(self):
18958 
    return
18959 
 
18960 
 
18961 
  def __repr__(self):
18962 
    L = ['%s=%r' % (key, value)
18963 
      for key, value in self.__dict__.iteritems()]
18964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18965 
 
18966 
  def __eq__(self, other):
18967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18968 
 
18969 
  def __ne__(self, other):
18970 
    return not (self == other)
4008 mandeep.dh 18971 
 
18972 
class getTransactionsRequiringExtraProcessing_args:
18973 
  """
18974 
  Attributes:
18975 
   - category
18976 
  """
18977 
 
18978 
  thrift_spec = (
18979 
    None, # 0
18980 
    (1, TType.I32, 'category', None, None, ), # 1
18981 
  )
18982 
 
18983 
  def __init__(self, category=None,):
18984 
    self.category = category
18985 
 
18986 
  def read(self, iprot):
18987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18989 
      return
18990 
    iprot.readStructBegin()
18991 
    while True:
18992 
      (fname, ftype, fid) = iprot.readFieldBegin()
18993 
      if ftype == TType.STOP:
18994 
        break
18995 
      if fid == 1:
18996 
        if ftype == TType.I32:
18997 
          self.category = iprot.readI32();
18998 
        else:
18999 
          iprot.skip(ftype)
19000 
      else:
19001 
        iprot.skip(ftype)
19002 
      iprot.readFieldEnd()
19003 
    iprot.readStructEnd()
19004 
 
19005 
  def write(self, oprot):
19006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19008 
      return
19009 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19010 
    if self.category is not None:
19011 
      oprot.writeFieldBegin('category', TType.I32, 1)
19012 
      oprot.writeI32(self.category)
19013 
      oprot.writeFieldEnd()
19014 
    oprot.writeFieldStop()
19015 
    oprot.writeStructEnd()
19016 
 
19017 
  def validate(self):
19018 
    return
19019 
 
19020 
 
19021 
  def __repr__(self):
19022 
    L = ['%s=%r' % (key, value)
19023 
      for key, value in self.__dict__.iteritems()]
19024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19025 
 
19026 
  def __eq__(self, other):
19027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19028 
 
19029 
  def __ne__(self, other):
19030 
    return not (self == other)
19031 
 
19032 
class getTransactionsRequiringExtraProcessing_result:
19033 
  """
19034 
  Attributes:
19035 
   - success
19036 
  """
19037 
 
19038 
  thrift_spec = (
19039 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19040 
  )
19041 
 
19042 
  def __init__(self, success=None,):
19043 
    self.success = success
19044 
 
19045 
  def read(self, iprot):
19046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19048 
      return
19049 
    iprot.readStructBegin()
19050 
    while True:
19051 
      (fname, ftype, fid) = iprot.readFieldBegin()
19052 
      if ftype == TType.STOP:
19053 
        break
19054 
      if fid == 0:
19055 
        if ftype == TType.LIST:
19056 
          self.success = []
6000 mandeep.dh 19057 
          (_etype438, _size435) = iprot.readListBegin()
19058 
          for _i439 in xrange(_size435):
19059 
            _elem440 = iprot.readI64();
19060 
            self.success.append(_elem440)
4008 mandeep.dh 19061 
          iprot.readListEnd()
19062 
        else:
19063 
          iprot.skip(ftype)
19064 
      else:
19065 
        iprot.skip(ftype)
19066 
      iprot.readFieldEnd()
19067 
    iprot.readStructEnd()
19068 
 
19069 
  def write(self, oprot):
19070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19072 
      return
19073 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19074 
    if self.success is not None:
19075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19076 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 19077 
      for iter441 in self.success:
19078 
        oprot.writeI64(iter441)
4008 mandeep.dh 19079 
      oprot.writeListEnd()
19080 
      oprot.writeFieldEnd()
19081 
    oprot.writeFieldStop()
19082 
    oprot.writeStructEnd()
19083 
 
19084 
  def validate(self):
19085 
    return
19086 
 
19087 
 
19088 
  def __repr__(self):
19089 
    L = ['%s=%r' % (key, value)
19090 
      for key, value in self.__dict__.iteritems()]
19091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19092 
 
19093 
  def __eq__(self, other):
19094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19095 
 
19096 
  def __ne__(self, other):
19097 
    return not (self == other)
19098 
 
19099 
class markTransactionAsProcessed_args:
19100 
  """
19101 
  Attributes:
19102 
   - transactionId
19103 
   - category
19104 
  """
19105 
 
19106 
  thrift_spec = (
19107 
    None, # 0
19108 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19109 
    (2, TType.I32, 'category', None, None, ), # 2
19110 
  )
19111 
 
19112 
  def __init__(self, transactionId=None, category=None,):
19113 
    self.transactionId = transactionId
19114 
    self.category = category
19115 
 
19116 
  def read(self, iprot):
19117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19119 
      return
19120 
    iprot.readStructBegin()
19121 
    while True:
19122 
      (fname, ftype, fid) = iprot.readFieldBegin()
19123 
      if ftype == TType.STOP:
19124 
        break
19125 
      if fid == 1:
19126 
        if ftype == TType.I64:
19127 
          self.transactionId = iprot.readI64();
19128 
        else:
19129 
          iprot.skip(ftype)
19130 
      elif fid == 2:
19131 
        if ftype == TType.I32:
19132 
          self.category = iprot.readI32();
19133 
        else:
19134 
          iprot.skip(ftype)
19135 
      else:
19136 
        iprot.skip(ftype)
19137 
      iprot.readFieldEnd()
19138 
    iprot.readStructEnd()
19139 
 
19140 
  def write(self, oprot):
19141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19143 
      return
19144 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19145 
    if self.transactionId is not None:
19146 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19147 
      oprot.writeI64(self.transactionId)
19148 
      oprot.writeFieldEnd()
19149 
    if self.category is not None:
19150 
      oprot.writeFieldBegin('category', TType.I32, 2)
19151 
      oprot.writeI32(self.category)
19152 
      oprot.writeFieldEnd()
19153 
    oprot.writeFieldStop()
19154 
    oprot.writeStructEnd()
19155 
 
19156 
  def validate(self):
19157 
    return
19158 
 
19159 
 
19160 
  def __repr__(self):
19161 
    L = ['%s=%r' % (key, value)
19162 
      for key, value in self.__dict__.iteritems()]
19163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19164 
 
19165 
  def __eq__(self, other):
19166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19167 
 
19168 
  def __ne__(self, other):
19169 
    return not (self == other)
19170 
 
19171 
class markTransactionAsProcessed_result:
19172 
 
19173 
  thrift_spec = (
19174 
  )
19175 
 
19176 
  def read(self, iprot):
19177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19179 
      return
19180 
    iprot.readStructBegin()
19181 
    while True:
19182 
      (fname, ftype, fid) = iprot.readFieldBegin()
19183 
      if ftype == TType.STOP:
19184 
        break
19185 
      else:
19186 
        iprot.skip(ftype)
19187 
      iprot.readFieldEnd()
19188 
    iprot.readStructEnd()
19189 
 
19190 
  def write(self, oprot):
19191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19193 
      return
19194 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19195 
    oprot.writeFieldStop()
19196 
    oprot.writeStructEnd()
19197 
 
19198 
  def validate(self):
19199 
    return
19200 
 
19201 
 
19202 
  def __repr__(self):
19203 
    L = ['%s=%r' % (key, value)
19204 
      for key, value in self.__dict__.iteritems()]
19205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19206 
 
19207 
  def __eq__(self, other):
19208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19209 
 
19210 
  def __ne__(self, other):
19211 
    return not (self == other)
4018 chandransh 19212 
 
19213 
class getItemWiseRiskyOrdersCount_args:
19214 
 
19215 
  thrift_spec = (
19216 
  )
19217 
 
19218 
  def read(self, iprot):
19219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19221 
      return
19222 
    iprot.readStructBegin()
19223 
    while True:
19224 
      (fname, ftype, fid) = iprot.readFieldBegin()
19225 
      if ftype == TType.STOP:
19226 
        break
19227 
      else:
19228 
        iprot.skip(ftype)
19229 
      iprot.readFieldEnd()
19230 
    iprot.readStructEnd()
19231 
 
19232 
  def write(self, oprot):
19233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19235 
      return
19236 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19237 
    oprot.writeFieldStop()
19238 
    oprot.writeStructEnd()
19239 
 
19240 
  def validate(self):
19241 
    return
19242 
 
19243 
 
19244 
  def __repr__(self):
19245 
    L = ['%s=%r' % (key, value)
19246 
      for key, value in self.__dict__.iteritems()]
19247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19248 
 
19249 
  def __eq__(self, other):
19250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19251 
 
19252 
  def __ne__(self, other):
19253 
    return not (self == other)
19254 
 
19255 
class getItemWiseRiskyOrdersCount_result:
19256 
  """
19257 
  Attributes:
19258 
   - success
19259 
  """
19260 
 
19261 
  thrift_spec = (
19262 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19263 
  )
19264 
 
19265 
  def __init__(self, success=None,):
19266 
    self.success = success
19267 
 
19268 
  def read(self, iprot):
19269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19271 
      return
19272 
    iprot.readStructBegin()
19273 
    while True:
19274 
      (fname, ftype, fid) = iprot.readFieldBegin()
19275 
      if ftype == TType.STOP:
19276 
        break
19277 
      if fid == 0:
19278 
        if ftype == TType.MAP:
19279 
          self.success = {}
6000 mandeep.dh 19280 
          (_ktype443, _vtype444, _size442 ) = iprot.readMapBegin()
19281 
          for _i446 in xrange(_size442):
19282 
            _key447 = iprot.readI64();
19283 
            _val448 = iprot.readI64();
19284 
            self.success[_key447] = _val448
4018 chandransh 19285 
          iprot.readMapEnd()
19286 
        else:
19287 
          iprot.skip(ftype)
19288 
      else:
19289 
        iprot.skip(ftype)
19290 
      iprot.readFieldEnd()
19291 
    iprot.readStructEnd()
19292 
 
19293 
  def write(self, oprot):
19294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19296 
      return
19297 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19298 
    if self.success is not None:
19299 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19300 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6000 mandeep.dh 19301 
      for kiter449,viter450 in self.success.items():
19302 
        oprot.writeI64(kiter449)
19303 
        oprot.writeI64(viter450)
4018 chandransh 19304 
      oprot.writeMapEnd()
19305 
      oprot.writeFieldEnd()
19306 
    oprot.writeFieldStop()
19307 
    oprot.writeStructEnd()
19308 
 
19309 
  def validate(self):
19310 
    return
19311 
 
19312 
 
19313 
  def __repr__(self):
19314 
    L = ['%s=%r' % (key, value)
19315 
      for key, value in self.__dict__.iteritems()]
19316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19317 
 
19318 
  def __eq__(self, other):
19319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19320 
 
19321 
  def __ne__(self, other):
19322 
    return not (self == other)
4247 rajveer 19323 
 
4295 varun.gupt 19324 
class getOrdersForItemIds_args:
19325 
  """
19326 
  Attributes:
19327 
   - itemIds
19328 
  """
19329 
 
19330 
  thrift_spec = (
19331 
    None, # 0
19332 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19333 
  )
19334 
 
19335 
  def __init__(self, itemIds=None,):
19336 
    self.itemIds = itemIds
19337 
 
19338 
  def read(self, iprot):
19339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19341 
      return
19342 
    iprot.readStructBegin()
19343 
    while True:
19344 
      (fname, ftype, fid) = iprot.readFieldBegin()
19345 
      if ftype == TType.STOP:
19346 
        break
19347 
      if fid == 1:
19348 
        if ftype == TType.LIST:
19349 
          self.itemIds = []
6000 mandeep.dh 19350 
          (_etype454, _size451) = iprot.readListBegin()
19351 
          for _i455 in xrange(_size451):
19352 
            _elem456 = iprot.readI64();
19353 
            self.itemIds.append(_elem456)
4295 varun.gupt 19354 
          iprot.readListEnd()
19355 
        else:
19356 
          iprot.skip(ftype)
19357 
      else:
19358 
        iprot.skip(ftype)
19359 
      iprot.readFieldEnd()
19360 
    iprot.readStructEnd()
19361 
 
19362 
  def write(self, oprot):
19363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19365 
      return
19366 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19367 
    if self.itemIds is not None:
19368 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19369 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6000 mandeep.dh 19370 
      for iter457 in self.itemIds:
19371 
        oprot.writeI64(iter457)
4295 varun.gupt 19372 
      oprot.writeListEnd()
19373 
      oprot.writeFieldEnd()
19374 
    oprot.writeFieldStop()
19375 
    oprot.writeStructEnd()
19376 
 
19377 
  def validate(self):
19378 
    return
19379 
 
19380 
 
19381 
  def __repr__(self):
19382 
    L = ['%s=%r' % (key, value)
19383 
      for key, value in self.__dict__.iteritems()]
19384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19385 
 
19386 
  def __eq__(self, other):
19387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19388 
 
19389 
  def __ne__(self, other):
19390 
    return not (self == other)
19391 
 
19392 
class getOrdersForItemIds_result:
19393 
  """
19394 
  Attributes:
19395 
   - success
19396 
  """
19397 
 
19398 
  thrift_spec = (
19399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19400 
  )
19401 
 
19402 
  def __init__(self, success=None,):
19403 
    self.success = success
19404 
 
19405 
  def read(self, iprot):
19406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19408 
      return
19409 
    iprot.readStructBegin()
19410 
    while True:
19411 
      (fname, ftype, fid) = iprot.readFieldBegin()
19412 
      if ftype == TType.STOP:
19413 
        break
19414 
      if fid == 0:
19415 
        if ftype == TType.LIST:
19416 
          self.success = []
6000 mandeep.dh 19417 
          (_etype461, _size458) = iprot.readListBegin()
19418 
          for _i462 in xrange(_size458):
19419 
            _elem463 = Order()
19420 
            _elem463.read(iprot)
19421 
            self.success.append(_elem463)
4295 varun.gupt 19422 
          iprot.readListEnd()
19423 
        else:
19424 
          iprot.skip(ftype)
19425 
      else:
19426 
        iprot.skip(ftype)
19427 
      iprot.readFieldEnd()
19428 
    iprot.readStructEnd()
19429 
 
19430 
  def write(self, oprot):
19431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19433 
      return
19434 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19435 
    if self.success is not None:
19436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 19438 
      for iter464 in self.success:
19439 
        iter464.write(oprot)
4295 varun.gupt 19440 
      oprot.writeListEnd()
19441 
      oprot.writeFieldEnd()
19442 
    oprot.writeFieldStop()
19443 
    oprot.writeStructEnd()
19444 
 
19445 
  def validate(self):
19446 
    return
19447 
 
19448 
 
19449 
  def __repr__(self):
19450 
    L = ['%s=%r' % (key, value)
19451 
      for key, value in self.__dict__.iteritems()]
19452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19453 
 
19454 
  def __eq__(self, other):
19455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19456 
 
19457 
  def __ne__(self, other):
19458 
    return not (self == other)
19459 
 
4247 rajveer 19460 
class markOrderCancellationRequestReceived_args:
19461 
  """
19462 
  Attributes:
19463 
   - orderId
19464 
  """
19465 
 
19466 
  thrift_spec = (
19467 
    None, # 0
19468 
    (1, TType.I64, 'orderId', None, None, ), # 1
19469 
  )
19470 
 
19471 
  def __init__(self, orderId=None,):
19472 
    self.orderId = orderId
19473 
 
19474 
  def read(self, iprot):
19475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19477 
      return
19478 
    iprot.readStructBegin()
19479 
    while True:
19480 
      (fname, ftype, fid) = iprot.readFieldBegin()
19481 
      if ftype == TType.STOP:
19482 
        break
19483 
      if fid == 1:
19484 
        if ftype == TType.I64:
19485 
          self.orderId = iprot.readI64();
19486 
        else:
19487 
          iprot.skip(ftype)
19488 
      else:
19489 
        iprot.skip(ftype)
19490 
      iprot.readFieldEnd()
19491 
    iprot.readStructEnd()
19492 
 
19493 
  def write(self, oprot):
19494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19496 
      return
19497 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19498 
    if self.orderId is not None:
19499 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19500 
      oprot.writeI64(self.orderId)
19501 
      oprot.writeFieldEnd()
19502 
    oprot.writeFieldStop()
19503 
    oprot.writeStructEnd()
19504 
 
19505 
  def validate(self):
19506 
    return
19507 
 
19508 
 
19509 
  def __repr__(self):
19510 
    L = ['%s=%r' % (key, value)
19511 
      for key, value in self.__dict__.iteritems()]
19512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19513 
 
19514 
  def __eq__(self, other):
19515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19516 
 
19517 
  def __ne__(self, other):
19518 
    return not (self == other)
19519 
 
19520 
class markOrderCancellationRequestReceived_result:
19521 
  """
19522 
  Attributes:
19523 
   - ex
19524 
  """
19525 
 
19526 
  thrift_spec = (
19527 
    None, # 0
19528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19529 
  )
19530 
 
19531 
  def __init__(self, ex=None,):
19532 
    self.ex = ex
19533 
 
19534 
  def read(self, iprot):
19535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19537 
      return
19538 
    iprot.readStructBegin()
19539 
    while True:
19540 
      (fname, ftype, fid) = iprot.readFieldBegin()
19541 
      if ftype == TType.STOP:
19542 
        break
19543 
      if fid == 1:
19544 
        if ftype == TType.STRUCT:
19545 
          self.ex = TransactionServiceException()
19546 
          self.ex.read(iprot)
19547 
        else:
19548 
          iprot.skip(ftype)
19549 
      else:
19550 
        iprot.skip(ftype)
19551 
      iprot.readFieldEnd()
19552 
    iprot.readStructEnd()
19553 
 
19554 
  def write(self, oprot):
19555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19557 
      return
19558 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19559 
    if self.ex is not None:
19560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19561 
      self.ex.write(oprot)
19562 
      oprot.writeFieldEnd()
19563 
    oprot.writeFieldStop()
19564 
    oprot.writeStructEnd()
19565 
 
19566 
  def validate(self):
19567 
    return
19568 
 
19569 
 
19570 
  def __repr__(self):
19571 
    L = ['%s=%r' % (key, value)
19572 
      for key, value in self.__dict__.iteritems()]
19573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19574 
 
19575 
  def __eq__(self, other):
19576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19577 
 
19578 
  def __ne__(self, other):
19579 
    return not (self == other)
19580 
 
19581 
class markOrderCancellationRequestConfirmed_args:
19582 
  """
19583 
  Attributes:
19584 
   - orderId
19585 
  """
19586 
 
19587 
  thrift_spec = (
19588 
    None, # 0
19589 
    (1, TType.I64, 'orderId', None, None, ), # 1
19590 
  )
19591 
 
19592 
  def __init__(self, orderId=None,):
19593 
    self.orderId = orderId
19594 
 
19595 
  def read(self, iprot):
19596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19598 
      return
19599 
    iprot.readStructBegin()
19600 
    while True:
19601 
      (fname, ftype, fid) = iprot.readFieldBegin()
19602 
      if ftype == TType.STOP:
19603 
        break
19604 
      if fid == 1:
19605 
        if ftype == TType.I64:
19606 
          self.orderId = iprot.readI64();
19607 
        else:
19608 
          iprot.skip(ftype)
19609 
      else:
19610 
        iprot.skip(ftype)
19611 
      iprot.readFieldEnd()
19612 
    iprot.readStructEnd()
19613 
 
19614 
  def write(self, oprot):
19615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19617 
      return
19618 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19619 
    if self.orderId is not None:
19620 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19621 
      oprot.writeI64(self.orderId)
19622 
      oprot.writeFieldEnd()
19623 
    oprot.writeFieldStop()
19624 
    oprot.writeStructEnd()
19625 
 
19626 
  def validate(self):
19627 
    return
19628 
 
19629 
 
19630 
  def __repr__(self):
19631 
    L = ['%s=%r' % (key, value)
19632 
      for key, value in self.__dict__.iteritems()]
19633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19634 
 
19635 
  def __eq__(self, other):
19636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19637 
 
19638 
  def __ne__(self, other):
19639 
    return not (self == other)
19640 
 
19641 
class markOrderCancellationRequestConfirmed_result:
19642 
  """
19643 
  Attributes:
19644 
   - ex
19645 
  """
19646 
 
19647 
  thrift_spec = (
19648 
    None, # 0
19649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19650 
  )
19651 
 
19652 
  def __init__(self, ex=None,):
19653 
    self.ex = ex
19654 
 
19655 
  def read(self, iprot):
19656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19658 
      return
19659 
    iprot.readStructBegin()
19660 
    while True:
19661 
      (fname, ftype, fid) = iprot.readFieldBegin()
19662 
      if ftype == TType.STOP:
19663 
        break
19664 
      if fid == 1:
19665 
        if ftype == TType.STRUCT:
19666 
          self.ex = TransactionServiceException()
19667 
          self.ex.read(iprot)
19668 
        else:
19669 
          iprot.skip(ftype)
19670 
      else:
19671 
        iprot.skip(ftype)
19672 
      iprot.readFieldEnd()
19673 
    iprot.readStructEnd()
19674 
 
19675 
  def write(self, oprot):
19676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19678 
      return
19679 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19680 
    if self.ex is not None:
19681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19682 
      self.ex.write(oprot)
19683 
      oprot.writeFieldEnd()
19684 
    oprot.writeFieldStop()
19685 
    oprot.writeStructEnd()
19686 
 
19687 
  def validate(self):
19688 
    return
19689 
 
19690 
 
19691 
  def __repr__(self):
19692 
    L = ['%s=%r' % (key, value)
19693 
      for key, value in self.__dict__.iteritems()]
19694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19695 
 
19696 
  def __eq__(self, other):
19697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19698 
 
19699 
  def __ne__(self, other):
19700 
    return not (self == other)
19701 
 
19702 
class markOrderCancellationRequestDenied_args:
19703 
  """
19704 
  Attributes:
19705 
   - orderId
19706 
  """
19707 
 
19708 
  thrift_spec = (
19709 
    None, # 0
19710 
    (1, TType.I64, 'orderId', None, None, ), # 1
19711 
  )
19712 
 
19713 
  def __init__(self, orderId=None,):
19714 
    self.orderId = orderId
19715 
 
19716 
  def read(self, iprot):
19717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19719 
      return
19720 
    iprot.readStructBegin()
19721 
    while True:
19722 
      (fname, ftype, fid) = iprot.readFieldBegin()
19723 
      if ftype == TType.STOP:
19724 
        break
19725 
      if fid == 1:
19726 
        if ftype == TType.I64:
19727 
          self.orderId = iprot.readI64();
19728 
        else:
19729 
          iprot.skip(ftype)
19730 
      else:
19731 
        iprot.skip(ftype)
19732 
      iprot.readFieldEnd()
19733 
    iprot.readStructEnd()
19734 
 
19735 
  def write(self, oprot):
19736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19738 
      return
19739 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19740 
    if self.orderId is not None:
19741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19742 
      oprot.writeI64(self.orderId)
19743 
      oprot.writeFieldEnd()
19744 
    oprot.writeFieldStop()
19745 
    oprot.writeStructEnd()
19746 
 
19747 
  def validate(self):
19748 
    return
19749 
 
19750 
 
19751 
  def __repr__(self):
19752 
    L = ['%s=%r' % (key, value)
19753 
      for key, value in self.__dict__.iteritems()]
19754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19755 
 
19756 
  def __eq__(self, other):
19757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19758 
 
19759 
  def __ne__(self, other):
19760 
    return not (self == other)
19761 
 
19762 
class markOrderCancellationRequestDenied_result:
19763 
  """
19764 
  Attributes:
19765 
   - ex
19766 
  """
19767 
 
19768 
  thrift_spec = (
19769 
    None, # 0
19770 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19771 
  )
19772 
 
19773 
  def __init__(self, ex=None,):
19774 
    self.ex = ex
19775 
 
19776 
  def read(self, iprot):
19777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19779 
      return
19780 
    iprot.readStructBegin()
19781 
    while True:
19782 
      (fname, ftype, fid) = iprot.readFieldBegin()
19783 
      if ftype == TType.STOP:
19784 
        break
19785 
      if fid == 1:
19786 
        if ftype == TType.STRUCT:
19787 
          self.ex = TransactionServiceException()
19788 
          self.ex.read(iprot)
19789 
        else:
19790 
          iprot.skip(ftype)
19791 
      else:
19792 
        iprot.skip(ftype)
19793 
      iprot.readFieldEnd()
19794 
    iprot.readStructEnd()
19795 
 
19796 
  def write(self, oprot):
19797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19799 
      return
19800 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19801 
    if self.ex is not None:
19802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19803 
      self.ex.write(oprot)
19804 
      oprot.writeFieldEnd()
19805 
    oprot.writeFieldStop()
19806 
    oprot.writeStructEnd()
19807 
 
19808 
  def validate(self):
19809 
    return
19810 
 
19811 
 
19812 
  def __repr__(self):
19813 
    L = ['%s=%r' % (key, value)
19814 
      for key, value in self.__dict__.iteritems()]
19815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19816 
 
19817 
  def __eq__(self, other):
19818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19819 
 
19820 
  def __ne__(self, other):
19821 
    return not (self == other)
19822 
 
4258 rajveer 19823 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19824 
  """
19825 
  Attributes:
4258 rajveer 19826 
   - transactionId
4247 rajveer 19827 
  """
19828 
 
19829 
  thrift_spec = (
19830 
    None, # 0
4258 rajveer 19831 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19832 
  )
19833 
 
4258 rajveer 19834 
  def __init__(self, transactionId=None,):
19835 
    self.transactionId = transactionId
4247 rajveer 19836 
 
19837 
  def read(self, iprot):
19838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19840 
      return
19841 
    iprot.readStructBegin()
19842 
    while True:
19843 
      (fname, ftype, fid) = iprot.readFieldBegin()
19844 
      if ftype == TType.STOP:
19845 
        break
19846 
      if fid == 1:
19847 
        if ftype == TType.I64:
4258 rajveer 19848 
          self.transactionId = iprot.readI64();
4247 rajveer 19849 
        else:
19850 
          iprot.skip(ftype)
19851 
      else:
19852 
        iprot.skip(ftype)
19853 
      iprot.readFieldEnd()
19854 
    iprot.readStructEnd()
19855 
 
19856 
  def write(self, oprot):
19857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19859 
      return
4258 rajveer 19860 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19861 
    if self.transactionId is not None:
19862 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19863 
      oprot.writeI64(self.transactionId)
4247 rajveer 19864 
      oprot.writeFieldEnd()
19865 
    oprot.writeFieldStop()
19866 
    oprot.writeStructEnd()
19867 
 
19868 
  def validate(self):
19869 
    return
19870 
 
19871 
 
19872 
  def __repr__(self):
19873 
    L = ['%s=%r' % (key, value)
19874 
      for key, value in self.__dict__.iteritems()]
19875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19876 
 
19877 
  def __eq__(self, other):
19878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19879 
 
19880 
  def __ne__(self, other):
19881 
    return not (self == other)
19882 
 
4258 rajveer 19883 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19884 
  """
19885 
  Attributes:
19886 
   - ex
19887 
  """
19888 
 
19889 
  thrift_spec = (
19890 
    None, # 0
19891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19892 
  )
19893 
 
19894 
  def __init__(self, ex=None,):
19895 
    self.ex = ex
19896 
 
19897 
  def read(self, iprot):
19898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19900 
      return
19901 
    iprot.readStructBegin()
19902 
    while True:
19903 
      (fname, ftype, fid) = iprot.readFieldBegin()
19904 
      if ftype == TType.STOP:
19905 
        break
19906 
      if fid == 1:
19907 
        if ftype == TType.STRUCT:
19908 
          self.ex = TransactionServiceException()
19909 
          self.ex.read(iprot)
19910 
        else:
19911 
          iprot.skip(ftype)
19912 
      else:
19913 
        iprot.skip(ftype)
19914 
      iprot.readFieldEnd()
19915 
    iprot.readStructEnd()
19916 
 
19917 
  def write(self, oprot):
19918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19920 
      return
4258 rajveer 19921 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19922 
    if self.ex is not None:
19923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19924 
      self.ex.write(oprot)
19925 
      oprot.writeFieldEnd()
19926 
    oprot.writeFieldStop()
19927 
    oprot.writeStructEnd()
19928 
 
19929 
  def validate(self):
19930 
    return
19931 
 
19932 
 
19933 
  def __repr__(self):
19934 
    L = ['%s=%r' % (key, value)
19935 
      for key, value in self.__dict__.iteritems()]
19936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19937 
 
19938 
  def __eq__(self, other):
19939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19940 
 
19941 
  def __ne__(self, other):
19942 
    return not (self == other)
4259 anupam.sin 19943 
 
19944 
class refundTransaction_args:
19945 
  """
19946 
  Attributes:
19947 
   - transactionId
19948 
   - refundedBy
19949 
   - reason
19950 
  """
19951 
 
19952 
  thrift_spec = (
19953 
    None, # 0
19954 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19955 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19956 
    (3, TType.STRING, 'reason', None, None, ), # 3
19957 
  )
19958 
 
19959 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19960 
    self.transactionId = transactionId
19961 
    self.refundedBy = refundedBy
19962 
    self.reason = reason
19963 
 
19964 
  def read(self, iprot):
19965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19967 
      return
19968 
    iprot.readStructBegin()
19969 
    while True:
19970 
      (fname, ftype, fid) = iprot.readFieldBegin()
19971 
      if ftype == TType.STOP:
19972 
        break
19973 
      if fid == 1:
19974 
        if ftype == TType.I64:
19975 
          self.transactionId = iprot.readI64();
19976 
        else:
19977 
          iprot.skip(ftype)
19978 
      elif fid == 2:
19979 
        if ftype == TType.STRING:
19980 
          self.refundedBy = iprot.readString();
19981 
        else:
19982 
          iprot.skip(ftype)
19983 
      elif fid == 3:
19984 
        if ftype == TType.STRING:
19985 
          self.reason = iprot.readString();
19986 
        else:
19987 
          iprot.skip(ftype)
19988 
      else:
19989 
        iprot.skip(ftype)
19990 
      iprot.readFieldEnd()
19991 
    iprot.readStructEnd()
19992 
 
19993 
  def write(self, oprot):
19994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19996 
      return
19997 
    oprot.writeStructBegin('refundTransaction_args')
19998 
    if self.transactionId is not None:
19999 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20000 
      oprot.writeI64(self.transactionId)
20001 
      oprot.writeFieldEnd()
20002 
    if self.refundedBy is not None:
20003 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20004 
      oprot.writeString(self.refundedBy)
20005 
      oprot.writeFieldEnd()
20006 
    if self.reason is not None:
20007 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20008 
      oprot.writeString(self.reason)
20009 
      oprot.writeFieldEnd()
20010 
    oprot.writeFieldStop()
20011 
    oprot.writeStructEnd()
20012 
 
20013 
  def validate(self):
20014 
    return
20015 
 
20016 
 
20017 
  def __repr__(self):
20018 
    L = ['%s=%r' % (key, value)
20019 
      for key, value in self.__dict__.iteritems()]
20020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20021 
 
20022 
  def __eq__(self, other):
20023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20024 
 
20025 
  def __ne__(self, other):
20026 
    return not (self == other)
20027 
 
20028 
class refundTransaction_result:
20029 
  """
20030 
  Attributes:
20031 
   - ex
20032 
  """
20033 
 
20034 
  thrift_spec = (
20035 
    None, # 0
20036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20037 
  )
20038 
 
20039 
  def __init__(self, ex=None,):
20040 
    self.ex = ex
20041 
 
20042 
  def read(self, iprot):
20043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20045 
      return
20046 
    iprot.readStructBegin()
20047 
    while True:
20048 
      (fname, ftype, fid) = iprot.readFieldBegin()
20049 
      if ftype == TType.STOP:
20050 
        break
20051 
      if fid == 1:
20052 
        if ftype == TType.STRUCT:
20053 
          self.ex = TransactionServiceException()
20054 
          self.ex.read(iprot)
20055 
        else:
20056 
          iprot.skip(ftype)
20057 
      else:
20058 
        iprot.skip(ftype)
20059 
      iprot.readFieldEnd()
20060 
    iprot.readStructEnd()
20061 
 
20062 
  def write(self, oprot):
20063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20065 
      return
20066 
    oprot.writeStructBegin('refundTransaction_result')
20067 
    if self.ex is not None:
20068 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20069 
      self.ex.write(oprot)
20070 
      oprot.writeFieldEnd()
20071 
    oprot.writeFieldStop()
20072 
    oprot.writeStructEnd()
20073 
 
20074 
  def validate(self):
20075 
    return
20076 
 
20077 
 
20078 
  def __repr__(self):
20079 
    L = ['%s=%r' % (key, value)
20080 
      for key, value in self.__dict__.iteritems()]
20081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20082 
 
20083 
  def __eq__(self, other):
20084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20085 
 
20086 
  def __ne__(self, other):
20087 
    return not (self == other)
4285 rajveer 20088 
 
4324 mandeep.dh 20089 
class updateShipmentAddress_args:
20090 
  """
20091 
  Attributes:
20092 
   - orderId
20093 
   - addressId
20094 
  """
20095 
 
20096 
  thrift_spec = (
20097 
    None, # 0
20098 
    (1, TType.I64, 'orderId', None, None, ), # 1
20099 
    (2, TType.I64, 'addressId', None, None, ), # 2
20100 
  )
20101 
 
20102 
  def __init__(self, orderId=None, addressId=None,):
20103 
    self.orderId = orderId
20104 
    self.addressId = addressId
20105 
 
20106 
  def read(self, iprot):
20107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20109 
      return
20110 
    iprot.readStructBegin()
20111 
    while True:
20112 
      (fname, ftype, fid) = iprot.readFieldBegin()
20113 
      if ftype == TType.STOP:
20114 
        break
20115 
      if fid == 1:
20116 
        if ftype == TType.I64:
20117 
          self.orderId = iprot.readI64();
20118 
        else:
20119 
          iprot.skip(ftype)
20120 
      elif fid == 2:
20121 
        if ftype == TType.I64:
20122 
          self.addressId = iprot.readI64();
20123 
        else:
20124 
          iprot.skip(ftype)
20125 
      else:
20126 
        iprot.skip(ftype)
20127 
      iprot.readFieldEnd()
20128 
    iprot.readStructEnd()
20129 
 
20130 
  def write(self, oprot):
20131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20133 
      return
20134 
    oprot.writeStructBegin('updateShipmentAddress_args')
20135 
    if self.orderId is not None:
20136 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20137 
      oprot.writeI64(self.orderId)
20138 
      oprot.writeFieldEnd()
20139 
    if self.addressId is not None:
20140 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20141 
      oprot.writeI64(self.addressId)
20142 
      oprot.writeFieldEnd()
20143 
    oprot.writeFieldStop()
20144 
    oprot.writeStructEnd()
20145 
 
20146 
  def validate(self):
20147 
    return
20148 
 
20149 
 
20150 
  def __repr__(self):
20151 
    L = ['%s=%r' % (key, value)
20152 
      for key, value in self.__dict__.iteritems()]
20153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20154 
 
20155 
  def __eq__(self, other):
20156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20157 
 
20158 
  def __ne__(self, other):
20159 
    return not (self == other)
20160 
 
20161 
class updateShipmentAddress_result:
20162 
  """
20163 
  Attributes:
20164 
   - ex
20165 
  """
20166 
 
20167 
  thrift_spec = (
20168 
    None, # 0
20169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20170 
  )
20171 
 
20172 
  def __init__(self, ex=None,):
20173 
    self.ex = ex
20174 
 
20175 
  def read(self, iprot):
20176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20178 
      return
20179 
    iprot.readStructBegin()
20180 
    while True:
20181 
      (fname, ftype, fid) = iprot.readFieldBegin()
20182 
      if ftype == TType.STOP:
20183 
        break
20184 
      if fid == 1:
20185 
        if ftype == TType.STRUCT:
20186 
          self.ex = TransactionServiceException()
20187 
          self.ex.read(iprot)
20188 
        else:
20189 
          iprot.skip(ftype)
20190 
      else:
20191 
        iprot.skip(ftype)
20192 
      iprot.readFieldEnd()
20193 
    iprot.readStructEnd()
20194 
 
20195 
  def write(self, oprot):
20196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20198 
      return
20199 
    oprot.writeStructBegin('updateShipmentAddress_result')
20200 
    if self.ex is not None:
20201 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20202 
      self.ex.write(oprot)
20203 
      oprot.writeFieldEnd()
20204 
    oprot.writeFieldStop()
20205 
    oprot.writeStructEnd()
20206 
 
20207 
  def validate(self):
20208 
    return
20209 
 
20210 
 
20211 
  def __repr__(self):
20212 
    L = ['%s=%r' % (key, value)
20213 
      for key, value in self.__dict__.iteritems()]
20214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20215 
 
20216 
  def __eq__(self, other):
20217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20218 
 
20219 
  def __ne__(self, other):
20220 
    return not (self == other)
20221 
 
4285 rajveer 20222 
class acceptOrdersForItemId_args:
20223 
  """
20224 
  Attributes:
20225 
   - itemId
20226 
   - inventory
20227 
  """
20228 
 
20229 
  thrift_spec = (
20230 
    None, # 0
20231 
    (1, TType.I64, 'itemId', None, None, ), # 1
20232 
    (2, TType.I64, 'inventory', None, None, ), # 2
20233 
  )
20234 
 
20235 
  def __init__(self, itemId=None, inventory=None,):
20236 
    self.itemId = itemId
20237 
    self.inventory = inventory
20238 
 
20239 
  def read(self, iprot):
20240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20242 
      return
20243 
    iprot.readStructBegin()
20244 
    while True:
20245 
      (fname, ftype, fid) = iprot.readFieldBegin()
20246 
      if ftype == TType.STOP:
20247 
        break
20248 
      if fid == 1:
20249 
        if ftype == TType.I64:
20250 
          self.itemId = iprot.readI64();
20251 
        else:
20252 
          iprot.skip(ftype)
20253 
      elif fid == 2:
20254 
        if ftype == TType.I64:
20255 
          self.inventory = iprot.readI64();
20256 
        else:
20257 
          iprot.skip(ftype)
20258 
      else:
20259 
        iprot.skip(ftype)
20260 
      iprot.readFieldEnd()
20261 
    iprot.readStructEnd()
20262 
 
20263 
  def write(self, oprot):
20264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20266 
      return
20267 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20268 
    if self.itemId is not None:
20269 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20270 
      oprot.writeI64(self.itemId)
20271 
      oprot.writeFieldEnd()
20272 
    if self.inventory is not None:
20273 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20274 
      oprot.writeI64(self.inventory)
20275 
      oprot.writeFieldEnd()
20276 
    oprot.writeFieldStop()
20277 
    oprot.writeStructEnd()
20278 
 
20279 
  def validate(self):
20280 
    return
20281 
 
20282 
 
20283 
  def __repr__(self):
20284 
    L = ['%s=%r' % (key, value)
20285 
      for key, value in self.__dict__.iteritems()]
20286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20287 
 
20288 
  def __eq__(self, other):
20289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20290 
 
20291 
  def __ne__(self, other):
20292 
    return not (self == other)
20293 
 
20294 
class acceptOrdersForItemId_result:
20295 
  """
20296 
  Attributes:
20297 
   - success
20298 
   - ex
20299 
  """
20300 
 
20301 
  thrift_spec = (
20302 
    (0, TType.BOOL, 'success', None, None, ), # 0
20303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20304 
  )
20305 
 
20306 
  def __init__(self, success=None, ex=None,):
20307 
    self.success = success
20308 
    self.ex = ex
20309 
 
20310 
  def read(self, iprot):
20311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20313 
      return
20314 
    iprot.readStructBegin()
20315 
    while True:
20316 
      (fname, ftype, fid) = iprot.readFieldBegin()
20317 
      if ftype == TType.STOP:
20318 
        break
20319 
      if fid == 0:
20320 
        if ftype == TType.BOOL:
20321 
          self.success = iprot.readBool();
20322 
        else:
20323 
          iprot.skip(ftype)
20324 
      elif fid == 1:
20325 
        if ftype == TType.STRUCT:
20326 
          self.ex = TransactionServiceException()
20327 
          self.ex.read(iprot)
20328 
        else:
20329 
          iprot.skip(ftype)
20330 
      else:
20331 
        iprot.skip(ftype)
20332 
      iprot.readFieldEnd()
20333 
    iprot.readStructEnd()
20334 
 
20335 
  def write(self, oprot):
20336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20338 
      return
20339 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20340 
    if self.success is not None:
20341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20342 
      oprot.writeBool(self.success)
20343 
      oprot.writeFieldEnd()
20344 
    if self.ex is not None:
20345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20346 
      self.ex.write(oprot)
20347 
      oprot.writeFieldEnd()
20348 
    oprot.writeFieldStop()
20349 
    oprot.writeStructEnd()
20350 
 
20351 
  def validate(self):
20352 
    return
20353 
 
20354 
 
20355 
  def __repr__(self):
20356 
    L = ['%s=%r' % (key, value)
20357 
      for key, value in self.__dict__.iteritems()]
20358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20359 
 
20360 
  def __eq__(self, other):
20361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20362 
 
20363 
  def __ne__(self, other):
20364 
    return not (self == other)
4303 rajveer 20365 
 
20366 
class markOrdersAsPORaised_args:
20367 
  """
20368 
  Attributes:
20369 
   - vendorId
20370 
   - itemId
20371 
   - quantity
20372 
   - estimate
4369 rajveer 20373 
   - isReminder
4303 rajveer 20374 
  """
20375 
 
20376 
  thrift_spec = (
20377 
    None, # 0
20378 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20379 
    (2, TType.I64, 'itemId', None, None, ), # 2
20380 
    (3, TType.I64, 'quantity', None, None, ), # 3
20381 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20382 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20383 
  )
20384 
 
4369 rajveer 20385 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20386 
    self.vendorId = vendorId
20387 
    self.itemId = itemId
20388 
    self.quantity = quantity
20389 
    self.estimate = estimate
4369 rajveer 20390 
    self.isReminder = isReminder
4303 rajveer 20391 
 
20392 
  def read(self, iprot):
20393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20395 
      return
20396 
    iprot.readStructBegin()
20397 
    while True:
20398 
      (fname, ftype, fid) = iprot.readFieldBegin()
20399 
      if ftype == TType.STOP:
20400 
        break
20401 
      if fid == 1:
20402 
        if ftype == TType.I64:
20403 
          self.vendorId = iprot.readI64();
20404 
        else:
20405 
          iprot.skip(ftype)
20406 
      elif fid == 2:
20407 
        if ftype == TType.I64:
20408 
          self.itemId = iprot.readI64();
20409 
        else:
20410 
          iprot.skip(ftype)
20411 
      elif fid == 3:
20412 
        if ftype == TType.I64:
20413 
          self.quantity = iprot.readI64();
20414 
        else:
20415 
          iprot.skip(ftype)
20416 
      elif fid == 4:
20417 
        if ftype == TType.I64:
20418 
          self.estimate = iprot.readI64();
20419 
        else:
20420 
          iprot.skip(ftype)
4369 rajveer 20421 
      elif fid == 5:
20422 
        if ftype == TType.BOOL:
20423 
          self.isReminder = iprot.readBool();
20424 
        else:
20425 
          iprot.skip(ftype)
4303 rajveer 20426 
      else:
20427 
        iprot.skip(ftype)
20428 
      iprot.readFieldEnd()
20429 
    iprot.readStructEnd()
20430 
 
20431 
  def write(self, oprot):
20432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20434 
      return
20435 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20436 
    if self.vendorId is not None:
20437 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20438 
      oprot.writeI64(self.vendorId)
20439 
      oprot.writeFieldEnd()
20440 
    if self.itemId is not None:
20441 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20442 
      oprot.writeI64(self.itemId)
20443 
      oprot.writeFieldEnd()
20444 
    if self.quantity is not None:
20445 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20446 
      oprot.writeI64(self.quantity)
20447 
      oprot.writeFieldEnd()
20448 
    if self.estimate is not None:
20449 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20450 
      oprot.writeI64(self.estimate)
20451 
      oprot.writeFieldEnd()
4369 rajveer 20452 
    if self.isReminder is not None:
20453 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20454 
      oprot.writeBool(self.isReminder)
20455 
      oprot.writeFieldEnd()
4303 rajveer 20456 
    oprot.writeFieldStop()
20457 
    oprot.writeStructEnd()
20458 
 
20459 
  def validate(self):
20460 
    return
20461 
 
20462 
 
20463 
  def __repr__(self):
20464 
    L = ['%s=%r' % (key, value)
20465 
      for key, value in self.__dict__.iteritems()]
20466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20467 
 
20468 
  def __eq__(self, other):
20469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20470 
 
20471 
  def __ne__(self, other):
20472 
    return not (self == other)
20473 
 
20474 
class markOrdersAsPORaised_result:
20475 
  """
20476 
  Attributes:
20477 
   - ex
20478 
  """
20479 
 
20480 
  thrift_spec = (
20481 
    None, # 0
20482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20483 
  )
20484 
 
20485 
  def __init__(self, ex=None,):
20486 
    self.ex = ex
20487 
 
20488 
  def read(self, iprot):
20489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20491 
      return
20492 
    iprot.readStructBegin()
20493 
    while True:
20494 
      (fname, ftype, fid) = iprot.readFieldBegin()
20495 
      if ftype == TType.STOP:
20496 
        break
20497 
      if fid == 1:
20498 
        if ftype == TType.STRUCT:
20499 
          self.ex = TransactionServiceException()
20500 
          self.ex.read(iprot)
20501 
        else:
20502 
          iprot.skip(ftype)
20503 
      else:
20504 
        iprot.skip(ftype)
20505 
      iprot.readFieldEnd()
20506 
    iprot.readStructEnd()
20507 
 
20508 
  def write(self, oprot):
20509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20511 
      return
20512 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20513 
    if self.ex is not None:
20514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20515 
      self.ex.write(oprot)
20516 
      oprot.writeFieldEnd()
20517 
    oprot.writeFieldStop()
20518 
    oprot.writeStructEnd()
20519 
 
20520 
  def validate(self):
20521 
    return
20522 
 
20523 
 
20524 
  def __repr__(self):
20525 
    L = ['%s=%r' % (key, value)
20526 
      for key, value in self.__dict__.iteritems()]
20527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20528 
 
20529 
  def __eq__(self, other):
20530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20531 
 
20532 
  def __ne__(self, other):
20533 
    return not (self == other)
20534 
 
20535 
class markOrdersAsReversalInitiated_args:
20536 
  """
20537 
  Attributes:
20538 
   - vendorId
20539 
   - itemId
20540 
   - quantity
20541 
   - estimate
4369 rajveer 20542 
   - isReminder
4303 rajveer 20543 
  """
20544 
 
20545 
  thrift_spec = (
20546 
    None, # 0
20547 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20548 
    (2, TType.I64, 'itemId', None, None, ), # 2
20549 
    (3, TType.I64, 'quantity', None, None, ), # 3
20550 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20551 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20552 
  )
20553 
 
4369 rajveer 20554 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20555 
    self.vendorId = vendorId
20556 
    self.itemId = itemId
20557 
    self.quantity = quantity
20558 
    self.estimate = estimate
4369 rajveer 20559 
    self.isReminder = isReminder
4303 rajveer 20560 
 
20561 
  def read(self, iprot):
20562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20564 
      return
20565 
    iprot.readStructBegin()
20566 
    while True:
20567 
      (fname, ftype, fid) = iprot.readFieldBegin()
20568 
      if ftype == TType.STOP:
20569 
        break
20570 
      if fid == 1:
20571 
        if ftype == TType.I64:
20572 
          self.vendorId = iprot.readI64();
20573 
        else:
20574 
          iprot.skip(ftype)
20575 
      elif fid == 2:
20576 
        if ftype == TType.I64:
20577 
          self.itemId = iprot.readI64();
20578 
        else:
20579 
          iprot.skip(ftype)
20580 
      elif fid == 3:
20581 
        if ftype == TType.I64:
20582 
          self.quantity = iprot.readI64();
20583 
        else:
20584 
          iprot.skip(ftype)
20585 
      elif fid == 4:
20586 
        if ftype == TType.I64:
20587 
          self.estimate = iprot.readI64();
20588 
        else:
20589 
          iprot.skip(ftype)
4369 rajveer 20590 
      elif fid == 5:
20591 
        if ftype == TType.BOOL:
20592 
          self.isReminder = iprot.readBool();
20593 
        else:
20594 
          iprot.skip(ftype)
4303 rajveer 20595 
      else:
20596 
        iprot.skip(ftype)
20597 
      iprot.readFieldEnd()
20598 
    iprot.readStructEnd()
20599 
 
20600 
  def write(self, oprot):
20601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20603 
      return
20604 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20605 
    if self.vendorId is not None:
20606 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20607 
      oprot.writeI64(self.vendorId)
20608 
      oprot.writeFieldEnd()
20609 
    if self.itemId is not None:
20610 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20611 
      oprot.writeI64(self.itemId)
20612 
      oprot.writeFieldEnd()
20613 
    if self.quantity is not None:
20614 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20615 
      oprot.writeI64(self.quantity)
20616 
      oprot.writeFieldEnd()
20617 
    if self.estimate is not None:
20618 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20619 
      oprot.writeI64(self.estimate)
20620 
      oprot.writeFieldEnd()
4369 rajveer 20621 
    if self.isReminder is not None:
20622 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20623 
      oprot.writeBool(self.isReminder)
20624 
      oprot.writeFieldEnd()
4303 rajveer 20625 
    oprot.writeFieldStop()
20626 
    oprot.writeStructEnd()
20627 
 
20628 
  def validate(self):
20629 
    return
20630 
 
20631 
 
20632 
  def __repr__(self):
20633 
    L = ['%s=%r' % (key, value)
20634 
      for key, value in self.__dict__.iteritems()]
20635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20636 
 
20637 
  def __eq__(self, other):
20638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20639 
 
20640 
  def __ne__(self, other):
20641 
    return not (self == other)
20642 
 
20643 
class markOrdersAsReversalInitiated_result:
20644 
  """
20645 
  Attributes:
20646 
   - ex
20647 
  """
20648 
 
20649 
  thrift_spec = (
20650 
    None, # 0
20651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20652 
  )
20653 
 
20654 
  def __init__(self, ex=None,):
20655 
    self.ex = ex
20656 
 
20657 
  def read(self, iprot):
20658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20660 
      return
20661 
    iprot.readStructBegin()
20662 
    while True:
20663 
      (fname, ftype, fid) = iprot.readFieldBegin()
20664 
      if ftype == TType.STOP:
20665 
        break
20666 
      if fid == 1:
20667 
        if ftype == TType.STRUCT:
20668 
          self.ex = TransactionServiceException()
20669 
          self.ex.read(iprot)
20670 
        else:
20671 
          iprot.skip(ftype)
20672 
      else:
20673 
        iprot.skip(ftype)
20674 
      iprot.readFieldEnd()
20675 
    iprot.readStructEnd()
20676 
 
20677 
  def write(self, oprot):
20678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20680 
      return
20681 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20682 
    if self.ex is not None:
20683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20684 
      self.ex.write(oprot)
20685 
      oprot.writeFieldEnd()
20686 
    oprot.writeFieldStop()
20687 
    oprot.writeStructEnd()
20688 
 
20689 
  def validate(self):
20690 
    return
20691 
 
20692 
 
20693 
  def __repr__(self):
20694 
    L = ['%s=%r' % (key, value)
20695 
      for key, value in self.__dict__.iteritems()]
20696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20697 
 
20698 
  def __eq__(self, other):
20699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20700 
 
20701 
  def __ne__(self, other):
20702 
    return not (self == other)
20703 
 
20704 
class markOrdersAsNotAvailabke_args:
20705 
  """
20706 
  Attributes:
20707 
   - vendorId
20708 
   - itemId
20709 
   - quantity
20710 
   - estimate
4369 rajveer 20711 
   - isReminder
4303 rajveer 20712 
  """
20713 
 
20714 
  thrift_spec = (
20715 
    None, # 0
20716 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20717 
    (2, TType.I64, 'itemId', None, None, ), # 2
20718 
    (3, TType.I64, 'quantity', None, None, ), # 3
20719 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20720 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20721 
  )
20722 
 
4369 rajveer 20723 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20724 
    self.vendorId = vendorId
20725 
    self.itemId = itemId
20726 
    self.quantity = quantity
20727 
    self.estimate = estimate
4369 rajveer 20728 
    self.isReminder = isReminder
4303 rajveer 20729 
 
20730 
  def read(self, iprot):
20731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20733 
      return
20734 
    iprot.readStructBegin()
20735 
    while True:
20736 
      (fname, ftype, fid) = iprot.readFieldBegin()
20737 
      if ftype == TType.STOP:
20738 
        break
20739 
      if fid == 1:
20740 
        if ftype == TType.I64:
20741 
          self.vendorId = iprot.readI64();
20742 
        else:
20743 
          iprot.skip(ftype)
20744 
      elif fid == 2:
20745 
        if ftype == TType.I64:
20746 
          self.itemId = iprot.readI64();
20747 
        else:
20748 
          iprot.skip(ftype)
20749 
      elif fid == 3:
20750 
        if ftype == TType.I64:
20751 
          self.quantity = iprot.readI64();
20752 
        else:
20753 
          iprot.skip(ftype)
20754 
      elif fid == 4:
20755 
        if ftype == TType.I64:
20756 
          self.estimate = iprot.readI64();
20757 
        else:
20758 
          iprot.skip(ftype)
4369 rajveer 20759 
      elif fid == 5:
20760 
        if ftype == TType.BOOL:
20761 
          self.isReminder = iprot.readBool();
20762 
        else:
20763 
          iprot.skip(ftype)
4303 rajveer 20764 
      else:
20765 
        iprot.skip(ftype)
20766 
      iprot.readFieldEnd()
20767 
    iprot.readStructEnd()
20768 
 
20769 
  def write(self, oprot):
20770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20772 
      return
20773 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20774 
    if self.vendorId is not None:
20775 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20776 
      oprot.writeI64(self.vendorId)
20777 
      oprot.writeFieldEnd()
20778 
    if self.itemId is not None:
20779 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20780 
      oprot.writeI64(self.itemId)
20781 
      oprot.writeFieldEnd()
20782 
    if self.quantity is not None:
20783 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20784 
      oprot.writeI64(self.quantity)
20785 
      oprot.writeFieldEnd()
20786 
    if self.estimate is not None:
20787 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20788 
      oprot.writeI64(self.estimate)
20789 
      oprot.writeFieldEnd()
4369 rajveer 20790 
    if self.isReminder is not None:
20791 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20792 
      oprot.writeBool(self.isReminder)
20793 
      oprot.writeFieldEnd()
4303 rajveer 20794 
    oprot.writeFieldStop()
20795 
    oprot.writeStructEnd()
20796 
 
20797 
  def validate(self):
20798 
    return
20799 
 
20800 
 
20801 
  def __repr__(self):
20802 
    L = ['%s=%r' % (key, value)
20803 
      for key, value in self.__dict__.iteritems()]
20804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20805 
 
20806 
  def __eq__(self, other):
20807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20808 
 
20809 
  def __ne__(self, other):
20810 
    return not (self == other)
20811 
 
20812 
class markOrdersAsNotAvailabke_result:
20813 
  """
20814 
  Attributes:
20815 
   - ex
20816 
  """
20817 
 
20818 
  thrift_spec = (
20819 
    None, # 0
20820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20821 
  )
20822 
 
20823 
  def __init__(self, ex=None,):
20824 
    self.ex = ex
20825 
 
20826 
  def read(self, iprot):
20827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20829 
      return
20830 
    iprot.readStructBegin()
20831 
    while True:
20832 
      (fname, ftype, fid) = iprot.readFieldBegin()
20833 
      if ftype == TType.STOP:
20834 
        break
20835 
      if fid == 1:
20836 
        if ftype == TType.STRUCT:
20837 
          self.ex = TransactionServiceException()
20838 
          self.ex.read(iprot)
20839 
        else:
20840 
          iprot.skip(ftype)
20841 
      else:
20842 
        iprot.skip(ftype)
20843 
      iprot.readFieldEnd()
20844 
    iprot.readStructEnd()
20845 
 
20846 
  def write(self, oprot):
20847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20849 
      return
20850 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20851 
    if self.ex is not None:
20852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20853 
      self.ex.write(oprot)
20854 
      oprot.writeFieldEnd()
20855 
    oprot.writeFieldStop()
20856 
    oprot.writeStructEnd()
20857 
 
20858 
  def validate(self):
20859 
    return
20860 
 
20861 
 
20862 
  def __repr__(self):
20863 
    L = ['%s=%r' % (key, value)
20864 
      for key, value in self.__dict__.iteritems()]
20865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20866 
 
20867 
  def __eq__(self, other):
20868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20869 
 
20870 
  def __ne__(self, other):
20871 
    return not (self == other)
4369 rajveer 20872 
 
20873 
class markOrdersAsTimeout_args:
20874 
  """
20875 
  Attributes:
20876 
   - vendorId
20877 
  """
20878 
 
20879 
  thrift_spec = (
20880 
    None, # 0
20881 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20882 
  )
20883 
 
20884 
  def __init__(self, vendorId=None,):
20885 
    self.vendorId = vendorId
20886 
 
20887 
  def read(self, iprot):
20888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20890 
      return
20891 
    iprot.readStructBegin()
20892 
    while True:
20893 
      (fname, ftype, fid) = iprot.readFieldBegin()
20894 
      if ftype == TType.STOP:
20895 
        break
20896 
      if fid == 1:
20897 
        if ftype == TType.I64:
20898 
          self.vendorId = iprot.readI64();
20899 
        else:
20900 
          iprot.skip(ftype)
20901 
      else:
20902 
        iprot.skip(ftype)
20903 
      iprot.readFieldEnd()
20904 
    iprot.readStructEnd()
20905 
 
20906 
  def write(self, oprot):
20907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20909 
      return
20910 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20911 
    if self.vendorId is not None:
20912 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20913 
      oprot.writeI64(self.vendorId)
20914 
      oprot.writeFieldEnd()
20915 
    oprot.writeFieldStop()
20916 
    oprot.writeStructEnd()
20917 
 
20918 
  def validate(self):
20919 
    return
20920 
 
20921 
 
20922 
  def __repr__(self):
20923 
    L = ['%s=%r' % (key, value)
20924 
      for key, value in self.__dict__.iteritems()]
20925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20926 
 
20927 
  def __eq__(self, other):
20928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20929 
 
20930 
  def __ne__(self, other):
20931 
    return not (self == other)
20932 
 
20933 
class markOrdersAsTimeout_result:
20934 
  """
20935 
  Attributes:
20936 
   - success
20937 
   - ex
20938 
  """
20939 
 
20940 
  thrift_spec = (
20941 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20942 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20943 
  )
20944 
 
20945 
  def __init__(self, success=None, ex=None,):
20946 
    self.success = success
20947 
    self.ex = ex
20948 
 
20949 
  def read(self, iprot):
20950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20952 
      return
20953 
    iprot.readStructBegin()
20954 
    while True:
20955 
      (fname, ftype, fid) = iprot.readFieldBegin()
20956 
      if ftype == TType.STOP:
20957 
        break
20958 
      if fid == 0:
20959 
        if ftype == TType.MAP:
20960 
          self.success = {}
6000 mandeep.dh 20961 
          (_ktype466, _vtype467, _size465 ) = iprot.readMapBegin()
20962 
          for _i469 in xrange(_size465):
20963 
            _key470 = iprot.readI32();
20964 
            _val471 = TimeoutSummary()
20965 
            _val471.read(iprot)
20966 
            self.success[_key470] = _val471
4369 rajveer 20967 
          iprot.readMapEnd()
20968 
        else:
20969 
          iprot.skip(ftype)
20970 
      elif fid == 1:
20971 
        if ftype == TType.STRUCT:
20972 
          self.ex = TransactionServiceException()
20973 
          self.ex.read(iprot)
20974 
        else:
20975 
          iprot.skip(ftype)
20976 
      else:
20977 
        iprot.skip(ftype)
20978 
      iprot.readFieldEnd()
20979 
    iprot.readStructEnd()
20980 
 
20981 
  def write(self, oprot):
20982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20984 
      return
20985 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20986 
    if self.success is not None:
20987 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20988 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6000 mandeep.dh 20989 
      for kiter472,viter473 in self.success.items():
20990 
        oprot.writeI32(kiter472)
20991 
        viter473.write(oprot)
4369 rajveer 20992 
      oprot.writeMapEnd()
20993 
      oprot.writeFieldEnd()
20994 
    if self.ex is not None:
20995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20996 
      self.ex.write(oprot)
20997 
      oprot.writeFieldEnd()
20998 
    oprot.writeFieldStop()
20999 
    oprot.writeStructEnd()
21000 
 
21001 
  def validate(self):
21002 
    return
21003 
 
21004 
 
21005 
  def __repr__(self):
21006 
    L = ['%s=%r' % (key, value)
21007 
      for key, value in self.__dict__.iteritems()]
21008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21009 
 
21010 
  def __eq__(self, other):
21011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21012 
 
21013 
  def __ne__(self, other):
21014 
    return not (self == other)
4386 anupam.sin 21015 
 
4662 rajveer 21016 
class markOrderAsLostInTransit_args:
21017 
  """
21018 
  Attributes:
21019 
   - orderId
21020 
  """
21021 
 
21022 
  thrift_spec = (
21023 
    None, # 0
21024 
    (1, TType.I64, 'orderId', None, None, ), # 1
21025 
  )
21026 
 
21027 
  def __init__(self, orderId=None,):
21028 
    self.orderId = orderId
21029 
 
21030 
  def read(self, iprot):
21031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21033 
      return
21034 
    iprot.readStructBegin()
21035 
    while True:
21036 
      (fname, ftype, fid) = iprot.readFieldBegin()
21037 
      if ftype == TType.STOP:
21038 
        break
21039 
      if fid == 1:
21040 
        if ftype == TType.I64:
21041 
          self.orderId = iprot.readI64();
21042 
        else:
21043 
          iprot.skip(ftype)
21044 
      else:
21045 
        iprot.skip(ftype)
21046 
      iprot.readFieldEnd()
21047 
    iprot.readStructEnd()
21048 
 
21049 
  def write(self, oprot):
21050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21052 
      return
21053 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21054 
    if self.orderId is not None:
21055 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21056 
      oprot.writeI64(self.orderId)
21057 
      oprot.writeFieldEnd()
21058 
    oprot.writeFieldStop()
21059 
    oprot.writeStructEnd()
21060 
 
21061 
  def validate(self):
21062 
    return
21063 
 
21064 
 
21065 
  def __repr__(self):
21066 
    L = ['%s=%r' % (key, value)
21067 
      for key, value in self.__dict__.iteritems()]
21068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21069 
 
21070 
  def __eq__(self, other):
21071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21072 
 
21073 
  def __ne__(self, other):
21074 
    return not (self == other)
21075 
 
21076 
class markOrderAsLostInTransit_result:
21077 
  """
21078 
  Attributes:
21079 
   - success
21080 
   - ex
21081 
  """
21082 
 
21083 
  thrift_spec = (
21084 
    (0, TType.BOOL, 'success', None, None, ), # 0
21085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21086 
  )
21087 
 
21088 
  def __init__(self, success=None, ex=None,):
21089 
    self.success = success
21090 
    self.ex = ex
21091 
 
21092 
  def read(self, iprot):
21093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21095 
      return
21096 
    iprot.readStructBegin()
21097 
    while True:
21098 
      (fname, ftype, fid) = iprot.readFieldBegin()
21099 
      if ftype == TType.STOP:
21100 
        break
21101 
      if fid == 0:
21102 
        if ftype == TType.BOOL:
21103 
          self.success = iprot.readBool();
21104 
        else:
21105 
          iprot.skip(ftype)
21106 
      elif fid == 1:
21107 
        if ftype == TType.STRUCT:
21108 
          self.ex = TransactionServiceException()
21109 
          self.ex.read(iprot)
21110 
        else:
21111 
          iprot.skip(ftype)
21112 
      else:
21113 
        iprot.skip(ftype)
21114 
      iprot.readFieldEnd()
21115 
    iprot.readStructEnd()
21116 
 
21117 
  def write(self, oprot):
21118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21120 
      return
21121 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21122 
    if self.success is not None:
21123 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21124 
      oprot.writeBool(self.success)
21125 
      oprot.writeFieldEnd()
21126 
    if self.ex is not None:
21127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21128 
      self.ex.write(oprot)
21129 
      oprot.writeFieldEnd()
21130 
    oprot.writeFieldStop()
21131 
    oprot.writeStructEnd()
21132 
 
21133 
  def validate(self):
21134 
    return
21135 
 
21136 
 
21137 
  def __repr__(self):
21138 
    L = ['%s=%r' % (key, value)
21139 
      for key, value in self.__dict__.iteritems()]
21140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21141 
 
21142 
  def __eq__(self, other):
21143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21144 
 
21145 
  def __ne__(self, other):
21146 
    return not (self == other)
21147 
 
4386 anupam.sin 21148 
class getOrderForAwb_args:
21149 
  """
21150 
  Attributes:
21151 
   - awb
21152 
  """
21153 
 
21154 
  thrift_spec = (
21155 
    None, # 0
21156 
    (1, TType.STRING, 'awb', None, None, ), # 1
21157 
  )
21158 
 
21159 
  def __init__(self, awb=None,):
21160 
    self.awb = awb
21161 
 
21162 
  def read(self, iprot):
21163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21165 
      return
21166 
    iprot.readStructBegin()
21167 
    while True:
21168 
      (fname, ftype, fid) = iprot.readFieldBegin()
21169 
      if ftype == TType.STOP:
21170 
        break
21171 
      if fid == 1:
21172 
        if ftype == TType.STRING:
21173 
          self.awb = iprot.readString();
21174 
        else:
21175 
          iprot.skip(ftype)
21176 
      else:
21177 
        iprot.skip(ftype)
21178 
      iprot.readFieldEnd()
21179 
    iprot.readStructEnd()
21180 
 
21181 
  def write(self, oprot):
21182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21184 
      return
21185 
    oprot.writeStructBegin('getOrderForAwb_args')
21186 
    if self.awb is not None:
21187 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21188 
      oprot.writeString(self.awb)
21189 
      oprot.writeFieldEnd()
21190 
    oprot.writeFieldStop()
21191 
    oprot.writeStructEnd()
21192 
 
21193 
  def validate(self):
21194 
    return
21195 
 
21196 
 
21197 
  def __repr__(self):
21198 
    L = ['%s=%r' % (key, value)
21199 
      for key, value in self.__dict__.iteritems()]
21200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21201 
 
21202 
  def __eq__(self, other):
21203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21204 
 
21205 
  def __ne__(self, other):
21206 
    return not (self == other)
21207 
 
21208 
class getOrderForAwb_result:
21209 
  """
21210 
  Attributes:
21211 
   - success
21212 
   - ex
21213 
  """
21214 
 
21215 
  thrift_spec = (
21216 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21217 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21218 
  )
21219 
 
21220 
  def __init__(self, success=None, ex=None,):
21221 
    self.success = success
21222 
    self.ex = ex
21223 
 
21224 
  def read(self, iprot):
21225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21227 
      return
21228 
    iprot.readStructBegin()
21229 
    while True:
21230 
      (fname, ftype, fid) = iprot.readFieldBegin()
21231 
      if ftype == TType.STOP:
21232 
        break
21233 
      if fid == 0:
21234 
        if ftype == TType.STRUCT:
21235 
          self.success = Order()
21236 
          self.success.read(iprot)
21237 
        else:
21238 
          iprot.skip(ftype)
21239 
      elif fid == 1:
21240 
        if ftype == TType.STRUCT:
21241 
          self.ex = TransactionServiceException()
21242 
          self.ex.read(iprot)
21243 
        else:
21244 
          iprot.skip(ftype)
21245 
      else:
21246 
        iprot.skip(ftype)
21247 
      iprot.readFieldEnd()
21248 
    iprot.readStructEnd()
21249 
 
21250 
  def write(self, oprot):
21251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21253 
      return
21254 
    oprot.writeStructBegin('getOrderForAwb_result')
21255 
    if self.success is not None:
21256 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21257 
      self.success.write(oprot)
21258 
      oprot.writeFieldEnd()
21259 
    if self.ex is not None:
21260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21261 
      self.ex.write(oprot)
21262 
      oprot.writeFieldEnd()
21263 
    oprot.writeFieldStop()
21264 
    oprot.writeStructEnd()
21265 
 
21266 
  def validate(self):
21267 
    return
21268 
 
21269 
 
21270 
  def __repr__(self):
21271 
    L = ['%s=%r' % (key, value)
21272 
      for key, value in self.__dict__.iteritems()]
21273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21274 
 
21275 
  def __eq__(self, other):
21276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21277 
 
21278 
  def __ne__(self, other):
21279 
    return not (self == other)
4506 phani.kuma 21280 
 
21281 
class getOrdersForProviderForStatus_args:
21282 
  """
21283 
  Attributes:
21284 
   - logistics_provider_id
4910 phani.kuma 21285 
   - order_status_list
4506 phani.kuma 21286 
  """
21287 
 
21288 
  thrift_spec = (
21289 
    None, # 0
21290 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21291 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21292 
  )
21293 
 
4910 phani.kuma 21294 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21295 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21296 
    self.order_status_list = order_status_list
4506 phani.kuma 21297 
 
21298 
  def read(self, iprot):
21299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21301 
      return
21302 
    iprot.readStructBegin()
21303 
    while True:
21304 
      (fname, ftype, fid) = iprot.readFieldBegin()
21305 
      if ftype == TType.STOP:
21306 
        break
21307 
      if fid == 1:
21308 
        if ftype == TType.I64:
21309 
          self.logistics_provider_id = iprot.readI64();
21310 
        else:
21311 
          iprot.skip(ftype)
21312 
      elif fid == 2:
4910 phani.kuma 21313 
        if ftype == TType.LIST:
21314 
          self.order_status_list = []
6000 mandeep.dh 21315 
          (_etype477, _size474) = iprot.readListBegin()
21316 
          for _i478 in xrange(_size474):
21317 
            _elem479 = iprot.readI32();
21318 
            self.order_status_list.append(_elem479)
4910 phani.kuma 21319 
          iprot.readListEnd()
4506 phani.kuma 21320 
        else:
21321 
          iprot.skip(ftype)
21322 
      else:
21323 
        iprot.skip(ftype)
21324 
      iprot.readFieldEnd()
21325 
    iprot.readStructEnd()
21326 
 
21327 
  def write(self, oprot):
21328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21330 
      return
21331 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21332 
    if self.logistics_provider_id is not None:
21333 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21334 
      oprot.writeI64(self.logistics_provider_id)
21335 
      oprot.writeFieldEnd()
4910 phani.kuma 21336 
    if self.order_status_list is not None:
21337 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21338 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6000 mandeep.dh 21339 
      for iter480 in self.order_status_list:
21340 
        oprot.writeI32(iter480)
4910 phani.kuma 21341 
      oprot.writeListEnd()
4506 phani.kuma 21342 
      oprot.writeFieldEnd()
21343 
    oprot.writeFieldStop()
21344 
    oprot.writeStructEnd()
21345 
 
21346 
  def validate(self):
21347 
    return
21348 
 
21349 
 
21350 
  def __repr__(self):
21351 
    L = ['%s=%r' % (key, value)
21352 
      for key, value in self.__dict__.iteritems()]
21353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21354 
 
21355 
  def __eq__(self, other):
21356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21357 
 
21358 
  def __ne__(self, other):
21359 
    return not (self == other)
21360 
 
21361 
class getOrdersForProviderForStatus_result:
21362 
  """
21363 
  Attributes:
21364 
   - success
21365 
   - ex
21366 
  """
21367 
 
21368 
  thrift_spec = (
21369 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21371 
  )
21372 
 
21373 
  def __init__(self, success=None, ex=None,):
21374 
    self.success = success
21375 
    self.ex = ex
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 0:
21387 
        if ftype == TType.LIST:
21388 
          self.success = []
6000 mandeep.dh 21389 
          (_etype484, _size481) = iprot.readListBegin()
21390 
          for _i485 in xrange(_size481):
21391 
            _elem486 = Order()
21392 
            _elem486.read(iprot)
21393 
            self.success.append(_elem486)
4506 phani.kuma 21394 
          iprot.readListEnd()
21395 
        else:
21396 
          iprot.skip(ftype)
21397 
      elif fid == 1:
21398 
        if ftype == TType.STRUCT:
21399 
          self.ex = TransactionServiceException()
21400 
          self.ex.read(iprot)
21401 
        else:
21402 
          iprot.skip(ftype)
21403 
      else:
21404 
        iprot.skip(ftype)
21405 
      iprot.readFieldEnd()
21406 
    iprot.readStructEnd()
21407 
 
21408 
  def write(self, oprot):
21409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21411 
      return
21412 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21413 
    if self.success is not None:
21414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21416 
      for iter487 in self.success:
21417 
        iter487.write(oprot)
4506 phani.kuma 21418 
      oprot.writeListEnd()
21419 
      oprot.writeFieldEnd()
21420 
    if self.ex is not None:
21421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21422 
      self.ex.write(oprot)
21423 
      oprot.writeFieldEnd()
21424 
    oprot.writeFieldStop()
21425 
    oprot.writeStructEnd()
21426 
 
21427 
  def validate(self):
21428 
    return
21429 
 
21430 
 
21431 
  def __repr__(self):
21432 
    L = ['%s=%r' % (key, value)
21433 
      for key, value in self.__dict__.iteritems()]
21434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21435 
 
21436 
  def __eq__(self, other):
21437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21438 
 
21439 
  def __ne__(self, other):
21440 
    return not (self == other)
4600 varun.gupt 21441 
 
21442 
class getBilledOrdersForVendor_args:
21443 
  """
21444 
  Attributes:
21445 
   - vendorId
21446 
   - billingDateFrom
21447 
   - billingDateTo
21448 
  """
21449 
 
21450 
  thrift_spec = (
21451 
    None, # 0
21452 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21453 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21454 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21455 
  )
21456 
 
21457 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21458 
    self.vendorId = vendorId
21459 
    self.billingDateFrom = billingDateFrom
21460 
    self.billingDateTo = billingDateTo
21461 
 
21462 
  def read(self, iprot):
21463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21465 
      return
21466 
    iprot.readStructBegin()
21467 
    while True:
21468 
      (fname, ftype, fid) = iprot.readFieldBegin()
21469 
      if ftype == TType.STOP:
21470 
        break
21471 
      if fid == 1:
21472 
        if ftype == TType.I64:
21473 
          self.vendorId = iprot.readI64();
21474 
        else:
21475 
          iprot.skip(ftype)
21476 
      elif fid == 2:
21477 
        if ftype == TType.I64:
21478 
          self.billingDateFrom = iprot.readI64();
21479 
        else:
21480 
          iprot.skip(ftype)
21481 
      elif fid == 3:
21482 
        if ftype == TType.I64:
21483 
          self.billingDateTo = iprot.readI64();
21484 
        else:
21485 
          iprot.skip(ftype)
21486 
      else:
21487 
        iprot.skip(ftype)
21488 
      iprot.readFieldEnd()
21489 
    iprot.readStructEnd()
21490 
 
21491 
  def write(self, oprot):
21492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21494 
      return
21495 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21496 
    if self.vendorId is not None:
21497 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21498 
      oprot.writeI64(self.vendorId)
21499 
      oprot.writeFieldEnd()
21500 
    if self.billingDateFrom is not None:
21501 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21502 
      oprot.writeI64(self.billingDateFrom)
21503 
      oprot.writeFieldEnd()
21504 
    if self.billingDateTo is not None:
21505 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21506 
      oprot.writeI64(self.billingDateTo)
21507 
      oprot.writeFieldEnd()
21508 
    oprot.writeFieldStop()
21509 
    oprot.writeStructEnd()
21510 
 
21511 
  def validate(self):
21512 
    return
21513 
 
21514 
 
21515 
  def __repr__(self):
21516 
    L = ['%s=%r' % (key, value)
21517 
      for key, value in self.__dict__.iteritems()]
21518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21519 
 
21520 
  def __eq__(self, other):
21521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21522 
 
21523 
  def __ne__(self, other):
21524 
    return not (self == other)
21525 
 
21526 
class getBilledOrdersForVendor_result:
21527 
  """
21528 
  Attributes:
21529 
   - success
21530 
   - ex
21531 
  """
21532 
 
21533 
  thrift_spec = (
21534 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21536 
  )
21537 
 
21538 
  def __init__(self, success=None, ex=None,):
21539 
    self.success = success
21540 
    self.ex = ex
21541 
 
21542 
  def read(self, iprot):
21543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21545 
      return
21546 
    iprot.readStructBegin()
21547 
    while True:
21548 
      (fname, ftype, fid) = iprot.readFieldBegin()
21549 
      if ftype == TType.STOP:
21550 
        break
21551 
      if fid == 0:
21552 
        if ftype == TType.LIST:
21553 
          self.success = []
6000 mandeep.dh 21554 
          (_etype491, _size488) = iprot.readListBegin()
21555 
          for _i492 in xrange(_size488):
21556 
            _elem493 = Order()
21557 
            _elem493.read(iprot)
21558 
            self.success.append(_elem493)
4600 varun.gupt 21559 
          iprot.readListEnd()
21560 
        else:
21561 
          iprot.skip(ftype)
21562 
      elif fid == 1:
21563 
        if ftype == TType.STRUCT:
21564 
          self.ex = TransactionServiceException()
21565 
          self.ex.read(iprot)
21566 
        else:
21567 
          iprot.skip(ftype)
21568 
      else:
21569 
        iprot.skip(ftype)
21570 
      iprot.readFieldEnd()
21571 
    iprot.readStructEnd()
21572 
 
21573 
  def write(self, oprot):
21574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21576 
      return
21577 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21578 
    if self.success is not None:
21579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21581 
      for iter494 in self.success:
21582 
        iter494.write(oprot)
4600 varun.gupt 21583 
      oprot.writeListEnd()
21584 
      oprot.writeFieldEnd()
21585 
    if self.ex is not None:
21586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21587 
      self.ex.write(oprot)
21588 
      oprot.writeFieldEnd()
21589 
    oprot.writeFieldStop()
21590 
    oprot.writeStructEnd()
21591 
 
21592 
  def validate(self):
21593 
    return
21594 
 
21595 
 
21596 
  def __repr__(self):
21597 
    L = ['%s=%r' % (key, value)
21598 
      for key, value in self.__dict__.iteritems()]
21599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21600 
 
21601 
  def __eq__(self, other):
21602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21603 
 
21604 
  def __ne__(self, other):
21605 
    return not (self == other)
21606 
 
4607 rajveer 21607 
class getSlippedSippingDateOrders_args:
21608 
 
21609 
  thrift_spec = (
21610 
  )
21611 
 
21612 
  def read(self, iprot):
21613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21615 
      return
21616 
    iprot.readStructBegin()
21617 
    while True:
21618 
      (fname, ftype, fid) = iprot.readFieldBegin()
21619 
      if ftype == TType.STOP:
21620 
        break
21621 
      else:
21622 
        iprot.skip(ftype)
21623 
      iprot.readFieldEnd()
21624 
    iprot.readStructEnd()
21625 
 
21626 
  def write(self, oprot):
21627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21629 
      return
21630 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21631 
    oprot.writeFieldStop()
21632 
    oprot.writeStructEnd()
21633 
 
21634 
  def validate(self):
21635 
    return
21636 
 
21637 
 
21638 
  def __repr__(self):
21639 
    L = ['%s=%r' % (key, value)
21640 
      for key, value in self.__dict__.iteritems()]
21641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21642 
 
21643 
  def __eq__(self, other):
21644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21645 
 
21646 
  def __ne__(self, other):
21647 
    return not (self == other)
21648 
 
21649 
class getSlippedSippingDateOrders_result:
21650 
  """
21651 
  Attributes:
21652 
   - success
21653 
   - ex
21654 
  """
21655 
 
21656 
  thrift_spec = (
21657 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21659 
  )
21660 
 
21661 
  def __init__(self, success=None, ex=None,):
21662 
    self.success = success
21663 
    self.ex = ex
21664 
 
21665 
  def read(self, iprot):
21666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21668 
      return
21669 
    iprot.readStructBegin()
21670 
    while True:
21671 
      (fname, ftype, fid) = iprot.readFieldBegin()
21672 
      if ftype == TType.STOP:
21673 
        break
21674 
      if fid == 0:
21675 
        if ftype == TType.LIST:
21676 
          self.success = []
6000 mandeep.dh 21677 
          (_etype498, _size495) = iprot.readListBegin()
21678 
          for _i499 in xrange(_size495):
21679 
            _elem500 = Order()
21680 
            _elem500.read(iprot)
21681 
            self.success.append(_elem500)
4607 rajveer 21682 
          iprot.readListEnd()
21683 
        else:
21684 
          iprot.skip(ftype)
21685 
      elif fid == 1:
21686 
        if ftype == TType.STRUCT:
21687 
          self.ex = TransactionServiceException()
21688 
          self.ex.read(iprot)
21689 
        else:
21690 
          iprot.skip(ftype)
21691 
      else:
21692 
        iprot.skip(ftype)
21693 
      iprot.readFieldEnd()
21694 
    iprot.readStructEnd()
21695 
 
21696 
  def write(self, oprot):
21697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21699 
      return
21700 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21701 
    if self.success is not None:
21702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21704 
      for iter501 in self.success:
21705 
        iter501.write(oprot)
4607 rajveer 21706 
      oprot.writeListEnd()
21707 
      oprot.writeFieldEnd()
21708 
    if self.ex is not None:
21709 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21710 
      self.ex.write(oprot)
21711 
      oprot.writeFieldEnd()
21712 
    oprot.writeFieldStop()
21713 
    oprot.writeStructEnd()
21714 
 
21715 
  def validate(self):
21716 
    return
21717 
 
21718 
 
21719 
  def __repr__(self):
21720 
    L = ['%s=%r' % (key, value)
21721 
      for key, value in self.__dict__.iteritems()]
21722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21723 
 
21724 
  def __eq__(self, other):
21725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21726 
 
21727 
  def __ne__(self, other):
21728 
    return not (self == other)
21729 
 
4709 rajveer 21730 
class getCancelledOrders_args:
21731 
  """
21732 
  Attributes:
21733 
   - cancelDateFrom
21734 
   - cancelDateTo
21735 
  """
21736 
 
21737 
  thrift_spec = (
21738 
    None, # 0
21739 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21740 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21741 
  )
21742 
 
21743 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21744 
    self.cancelDateFrom = cancelDateFrom
21745 
    self.cancelDateTo = cancelDateTo
21746 
 
21747 
  def read(self, iprot):
21748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21750 
      return
21751 
    iprot.readStructBegin()
21752 
    while True:
21753 
      (fname, ftype, fid) = iprot.readFieldBegin()
21754 
      if ftype == TType.STOP:
21755 
        break
21756 
      if fid == 1:
21757 
        if ftype == TType.I64:
21758 
          self.cancelDateFrom = iprot.readI64();
21759 
        else:
21760 
          iprot.skip(ftype)
21761 
      elif fid == 2:
21762 
        if ftype == TType.I64:
21763 
          self.cancelDateTo = iprot.readI64();
21764 
        else:
21765 
          iprot.skip(ftype)
21766 
      else:
21767 
        iprot.skip(ftype)
21768 
      iprot.readFieldEnd()
21769 
    iprot.readStructEnd()
21770 
 
21771 
  def write(self, oprot):
21772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21774 
      return
21775 
    oprot.writeStructBegin('getCancelledOrders_args')
21776 
    if self.cancelDateFrom is not None:
21777 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21778 
      oprot.writeI64(self.cancelDateFrom)
21779 
      oprot.writeFieldEnd()
21780 
    if self.cancelDateTo is not None:
21781 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21782 
      oprot.writeI64(self.cancelDateTo)
21783 
      oprot.writeFieldEnd()
21784 
    oprot.writeFieldStop()
21785 
    oprot.writeStructEnd()
21786 
 
21787 
  def validate(self):
21788 
    return
21789 
 
21790 
 
21791 
  def __repr__(self):
21792 
    L = ['%s=%r' % (key, value)
21793 
      for key, value in self.__dict__.iteritems()]
21794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21795 
 
21796 
  def __eq__(self, other):
21797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21798 
 
21799 
  def __ne__(self, other):
21800 
    return not (self == other)
21801 
 
21802 
class getCancelledOrders_result:
21803 
  """
21804 
  Attributes:
21805 
   - success
21806 
   - ex
21807 
  """
21808 
 
21809 
  thrift_spec = (
21810 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21812 
  )
21813 
 
21814 
  def __init__(self, success=None, ex=None,):
21815 
    self.success = success
21816 
    self.ex = ex
21817 
 
21818 
  def read(self, iprot):
21819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21821 
      return
21822 
    iprot.readStructBegin()
21823 
    while True:
21824 
      (fname, ftype, fid) = iprot.readFieldBegin()
21825 
      if ftype == TType.STOP:
21826 
        break
21827 
      if fid == 0:
21828 
        if ftype == TType.LIST:
21829 
          self.success = []
6000 mandeep.dh 21830 
          (_etype505, _size502) = iprot.readListBegin()
21831 
          for _i506 in xrange(_size502):
21832 
            _elem507 = Order()
21833 
            _elem507.read(iprot)
21834 
            self.success.append(_elem507)
4709 rajveer 21835 
          iprot.readListEnd()
21836 
        else:
21837 
          iprot.skip(ftype)
21838 
      elif fid == 1:
21839 
        if ftype == TType.STRUCT:
21840 
          self.ex = TransactionServiceException()
21841 
          self.ex.read(iprot)
21842 
        else:
21843 
          iprot.skip(ftype)
21844 
      else:
21845 
        iprot.skip(ftype)
21846 
      iprot.readFieldEnd()
21847 
    iprot.readStructEnd()
21848 
 
21849 
  def write(self, oprot):
21850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21852 
      return
21853 
    oprot.writeStructBegin('getCancelledOrders_result')
21854 
    if self.success is not None:
21855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21857 
      for iter508 in self.success:
21858 
        iter508.write(oprot)
4709 rajveer 21859 
      oprot.writeListEnd()
21860 
      oprot.writeFieldEnd()
21861 
    if self.ex is not None:
21862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21863 
      self.ex.write(oprot)
21864 
      oprot.writeFieldEnd()
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
21882 
 
4600 varun.gupt 21883 
class saveBluedartSettlements_args:
21884 
  """
21885 
  Attributes:
21886 
   - mapAWBAndAmount
21887 
  """
21888 
 
21889 
  thrift_spec = (
21890 
    None, # 0
21891 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21892 
  )
21893 
 
21894 
  def __init__(self, mapAWBAndAmount=None,):
21895 
    self.mapAWBAndAmount = mapAWBAndAmount
21896 
 
21897 
  def read(self, iprot):
21898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21900 
      return
21901 
    iprot.readStructBegin()
21902 
    while True:
21903 
      (fname, ftype, fid) = iprot.readFieldBegin()
21904 
      if ftype == TType.STOP:
21905 
        break
21906 
      if fid == 1:
21907 
        if ftype == TType.MAP:
21908 
          self.mapAWBAndAmount = {}
6000 mandeep.dh 21909 
          (_ktype510, _vtype511, _size509 ) = iprot.readMapBegin()
21910 
          for _i513 in xrange(_size509):
21911 
            _key514 = iprot.readI64();
21912 
            _val515 = iprot.readDouble();
21913 
            self.mapAWBAndAmount[_key514] = _val515
4600 varun.gupt 21914 
          iprot.readMapEnd()
21915 
        else:
21916 
          iprot.skip(ftype)
21917 
      else:
21918 
        iprot.skip(ftype)
21919 
      iprot.readFieldEnd()
21920 
    iprot.readStructEnd()
21921 
 
21922 
  def write(self, oprot):
21923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21925 
      return
21926 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21927 
    if self.mapAWBAndAmount is not None:
21928 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21929 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6000 mandeep.dh 21930 
      for kiter516,viter517 in self.mapAWBAndAmount.items():
21931 
        oprot.writeI64(kiter516)
21932 
        oprot.writeDouble(viter517)
4600 varun.gupt 21933 
      oprot.writeMapEnd()
21934 
      oprot.writeFieldEnd()
21935 
    oprot.writeFieldStop()
21936 
    oprot.writeStructEnd()
21937 
 
21938 
  def validate(self):
21939 
    return
21940 
 
21941 
 
21942 
  def __repr__(self):
21943 
    L = ['%s=%r' % (key, value)
21944 
      for key, value in self.__dict__.iteritems()]
21945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21946 
 
21947 
  def __eq__(self, other):
21948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21949 
 
21950 
  def __ne__(self, other):
21951 
    return not (self == other)
21952 
 
21953 
class saveBluedartSettlements_result:
21954 
  """
21955 
  Attributes:
21956 
   - ex
21957 
  """
21958 
 
21959 
  thrift_spec = (
21960 
    None, # 0
21961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21962 
  )
21963 
 
21964 
  def __init__(self, ex=None,):
21965 
    self.ex = ex
21966 
 
21967 
  def read(self, iprot):
21968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21970 
      return
21971 
    iprot.readStructBegin()
21972 
    while True:
21973 
      (fname, ftype, fid) = iprot.readFieldBegin()
21974 
      if ftype == TType.STOP:
21975 
        break
21976 
      if fid == 1:
21977 
        if ftype == TType.STRUCT:
21978 
          self.ex = TransactionServiceException()
21979 
          self.ex.read(iprot)
21980 
        else:
21981 
          iprot.skip(ftype)
21982 
      else:
21983 
        iprot.skip(ftype)
21984 
      iprot.readFieldEnd()
21985 
    iprot.readStructEnd()
21986 
 
21987 
  def write(self, oprot):
21988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21990 
      return
21991 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21992 
    if self.ex is not None:
21993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21994 
      self.ex.write(oprot)
21995 
      oprot.writeFieldEnd()
21996 
    oprot.writeFieldStop()
21997 
    oprot.writeStructEnd()
21998 
 
21999 
  def validate(self):
22000 
    return
22001 
 
22002 
 
22003 
  def __repr__(self):
22004 
    L = ['%s=%r' % (key, value)
22005 
      for key, value in self.__dict__.iteritems()]
22006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22007 
 
22008 
  def __eq__(self, other):
22009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22010 
 
22011 
  def __ne__(self, other):
22012 
    return not (self == other)
22013 
 
22014 
class savePaymentSettlements_args:
22015 
  """
22016 
  Attributes:
22017 
   - settlementDate
22018 
   - paymentGatewayId
4905 varun.gupt 22019 
   - referenceId
4600 varun.gupt 22020 
   - serviceTax
22021 
   - otherCharges
22022 
   - netCollection
22023 
  """
22024 
 
22025 
  thrift_spec = (
22026 
    None, # 0
22027 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22028 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22029 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22030 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22031 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22032 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22033 
  )
22034 
 
4905 varun.gupt 22035 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22036 
    self.settlementDate = settlementDate
22037 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22038 
    self.referenceId = referenceId
4600 varun.gupt 22039 
    self.serviceTax = serviceTax
22040 
    self.otherCharges = otherCharges
22041 
    self.netCollection = netCollection
22042 
 
22043 
  def read(self, iprot):
22044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22046 
      return
22047 
    iprot.readStructBegin()
22048 
    while True:
22049 
      (fname, ftype, fid) = iprot.readFieldBegin()
22050 
      if ftype == TType.STOP:
22051 
        break
22052 
      if fid == 1:
22053 
        if ftype == TType.I64:
22054 
          self.settlementDate = iprot.readI64();
22055 
        else:
22056 
          iprot.skip(ftype)
22057 
      elif fid == 2:
22058 
        if ftype == TType.I64:
22059 
          self.paymentGatewayId = iprot.readI64();
22060 
        else:
22061 
          iprot.skip(ftype)
22062 
      elif fid == 3:
22063 
        if ftype == TType.I64:
4905 varun.gupt 22064 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22065 
        else:
22066 
          iprot.skip(ftype)
22067 
      elif fid == 4:
22068 
        if ftype == TType.DOUBLE:
22069 
          self.serviceTax = iprot.readDouble();
22070 
        else:
22071 
          iprot.skip(ftype)
22072 
      elif fid == 5:
22073 
        if ftype == TType.DOUBLE:
22074 
          self.otherCharges = iprot.readDouble();
22075 
        else:
22076 
          iprot.skip(ftype)
22077 
      elif fid == 6:
22078 
        if ftype == TType.DOUBLE:
22079 
          self.netCollection = iprot.readDouble();
22080 
        else:
22081 
          iprot.skip(ftype)
22082 
      else:
22083 
        iprot.skip(ftype)
22084 
      iprot.readFieldEnd()
22085 
    iprot.readStructEnd()
22086 
 
22087 
  def write(self, oprot):
22088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22090 
      return
22091 
    oprot.writeStructBegin('savePaymentSettlements_args')
22092 
    if self.settlementDate is not None:
22093 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22094 
      oprot.writeI64(self.settlementDate)
22095 
      oprot.writeFieldEnd()
22096 
    if self.paymentGatewayId is not None:
22097 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22098 
      oprot.writeI64(self.paymentGatewayId)
22099 
      oprot.writeFieldEnd()
4905 varun.gupt 22100 
    if self.referenceId is not None:
22101 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22102 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22103 
      oprot.writeFieldEnd()
22104 
    if self.serviceTax is not None:
22105 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22106 
      oprot.writeDouble(self.serviceTax)
22107 
      oprot.writeFieldEnd()
22108 
    if self.otherCharges is not None:
22109 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22110 
      oprot.writeDouble(self.otherCharges)
22111 
      oprot.writeFieldEnd()
22112 
    if self.netCollection is not None:
22113 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22114 
      oprot.writeDouble(self.netCollection)
22115 
      oprot.writeFieldEnd()
22116 
    oprot.writeFieldStop()
22117 
    oprot.writeStructEnd()
22118 
 
22119 
  def validate(self):
22120 
    return
22121 
 
22122 
 
22123 
  def __repr__(self):
22124 
    L = ['%s=%r' % (key, value)
22125 
      for key, value in self.__dict__.iteritems()]
22126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22127 
 
22128 
  def __eq__(self, other):
22129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22130 
 
22131 
  def __ne__(self, other):
22132 
    return not (self == other)
22133 
 
22134 
class savePaymentSettlements_result:
22135 
  """
22136 
  Attributes:
22137 
   - ex
22138 
  """
22139 
 
22140 
  thrift_spec = (
22141 
    None, # 0
22142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22143 
  )
22144 
 
22145 
  def __init__(self, ex=None,):
22146 
    self.ex = ex
22147 
 
22148 
  def read(self, iprot):
22149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22151 
      return
22152 
    iprot.readStructBegin()
22153 
    while True:
22154 
      (fname, ftype, fid) = iprot.readFieldBegin()
22155 
      if ftype == TType.STOP:
22156 
        break
22157 
      if fid == 1:
22158 
        if ftype == TType.STRUCT:
22159 
          self.ex = TransactionServiceException()
22160 
          self.ex.read(iprot)
22161 
        else:
22162 
          iprot.skip(ftype)
22163 
      else:
22164 
        iprot.skip(ftype)
22165 
      iprot.readFieldEnd()
22166 
    iprot.readStructEnd()
22167 
 
22168 
  def write(self, oprot):
22169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22171 
      return
22172 
    oprot.writeStructBegin('savePaymentSettlements_result')
22173 
    if self.ex is not None:
22174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22175 
      self.ex.write(oprot)
22176 
      oprot.writeFieldEnd()
22177 
    oprot.writeFieldStop()
22178 
    oprot.writeStructEnd()
22179 
 
22180 
  def validate(self):
22181 
    return
22182 
 
22183 
 
22184 
  def __repr__(self):
22185 
    L = ['%s=%r' % (key, value)
22186 
      for key, value in self.__dict__.iteritems()]
22187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22188 
 
22189 
  def __eq__(self, other):
22190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22191 
 
22192 
  def __ne__(self, other):
22193 
    return not (self == other)
22194 
 
22195 
class saveEBSSettlementSummary_args:
22196 
  """
22197 
  Attributes:
22198 
   - settlementId
22199 
   - settlementDate
22200 
   - transactionDateFrom
22201 
   - transactionDateTo
22202 
   - amount
22203 
  """
22204 
 
22205 
  thrift_spec = (
22206 
    None, # 0
22207 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22208 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22209 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22210 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22211 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22212 
  )
22213 
 
22214 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22215 
    self.settlementId = settlementId
22216 
    self.settlementDate = settlementDate
22217 
    self.transactionDateFrom = transactionDateFrom
22218 
    self.transactionDateTo = transactionDateTo
22219 
    self.amount = amount
22220 
 
22221 
  def read(self, iprot):
22222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22224 
      return
22225 
    iprot.readStructBegin()
22226 
    while True:
22227 
      (fname, ftype, fid) = iprot.readFieldBegin()
22228 
      if ftype == TType.STOP:
22229 
        break
22230 
      if fid == 1:
22231 
        if ftype == TType.I64:
22232 
          self.settlementId = iprot.readI64();
22233 
        else:
22234 
          iprot.skip(ftype)
22235 
      elif fid == 2:
22236 
        if ftype == TType.I64:
22237 
          self.settlementDate = iprot.readI64();
22238 
        else:
22239 
          iprot.skip(ftype)
22240 
      elif fid == 3:
22241 
        if ftype == TType.I64:
22242 
          self.transactionDateFrom = iprot.readI64();
22243 
        else:
22244 
          iprot.skip(ftype)
22245 
      elif fid == 4:
22246 
        if ftype == TType.I64:
22247 
          self.transactionDateTo = iprot.readI64();
22248 
        else:
22249 
          iprot.skip(ftype)
22250 
      elif fid == 5:
22251 
        if ftype == TType.DOUBLE:
22252 
          self.amount = iprot.readDouble();
22253 
        else:
22254 
          iprot.skip(ftype)
22255 
      else:
22256 
        iprot.skip(ftype)
22257 
      iprot.readFieldEnd()
22258 
    iprot.readStructEnd()
22259 
 
22260 
  def write(self, oprot):
22261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22263 
      return
22264 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22265 
    if self.settlementId is not None:
22266 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22267 
      oprot.writeI64(self.settlementId)
22268 
      oprot.writeFieldEnd()
22269 
    if self.settlementDate is not None:
22270 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22271 
      oprot.writeI64(self.settlementDate)
22272 
      oprot.writeFieldEnd()
22273 
    if self.transactionDateFrom is not None:
22274 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22275 
      oprot.writeI64(self.transactionDateFrom)
22276 
      oprot.writeFieldEnd()
22277 
    if self.transactionDateTo is not None:
22278 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22279 
      oprot.writeI64(self.transactionDateTo)
22280 
      oprot.writeFieldEnd()
22281 
    if self.amount is not None:
22282 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22283 
      oprot.writeDouble(self.amount)
22284 
      oprot.writeFieldEnd()
22285 
    oprot.writeFieldStop()
22286 
    oprot.writeStructEnd()
22287 
 
22288 
  def validate(self):
22289 
    return
22290 
 
22291 
 
22292 
  def __repr__(self):
22293 
    L = ['%s=%r' % (key, value)
22294 
      for key, value in self.__dict__.iteritems()]
22295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22296 
 
22297 
  def __eq__(self, other):
22298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22299 
 
22300 
  def __ne__(self, other):
22301 
    return not (self == other)
22302 
 
22303 
class saveEBSSettlementSummary_result:
22304 
  """
22305 
  Attributes:
22306 
   - ex
22307 
  """
22308 
 
22309 
  thrift_spec = (
22310 
    None, # 0
22311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22312 
  )
22313 
 
22314 
  def __init__(self, ex=None,):
22315 
    self.ex = ex
22316 
 
22317 
  def read(self, iprot):
22318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22320 
      return
22321 
    iprot.readStructBegin()
22322 
    while True:
22323 
      (fname, ftype, fid) = iprot.readFieldBegin()
22324 
      if ftype == TType.STOP:
22325 
        break
22326 
      if fid == 1:
22327 
        if ftype == TType.STRUCT:
22328 
          self.ex = TransactionServiceException()
22329 
          self.ex.read(iprot)
22330 
        else:
22331 
          iprot.skip(ftype)
22332 
      else:
22333 
        iprot.skip(ftype)
22334 
      iprot.readFieldEnd()
22335 
    iprot.readStructEnd()
22336 
 
22337 
  def write(self, oprot):
22338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22340 
      return
22341 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22342 
    if self.ex is not None:
22343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22344 
      self.ex.write(oprot)
22345 
      oprot.writeFieldEnd()
22346 
    oprot.writeFieldStop()
22347 
    oprot.writeStructEnd()
22348 
 
22349 
  def validate(self):
22350 
    return
22351 
 
22352 
 
22353 
  def __repr__(self):
22354 
    L = ['%s=%r' % (key, value)
22355 
      for key, value in self.__dict__.iteritems()]
22356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22357 
 
22358 
  def __eq__(self, other):
22359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22360 
 
22361 
  def __ne__(self, other):
22362 
    return not (self == other)
22363 
 
5386 phani.kuma 22364 
class getSettlementForPrepaid_args:
4600 varun.gupt 22365 
  """
22366 
  Attributes:
5189 varun.gupt 22367 
   - referenceId
22368 
   - isRefund
4600 varun.gupt 22369 
  """
22370 
 
22371 
  thrift_spec = (
22372 
    None, # 0
5189 varun.gupt 22373 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22374 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22375 
  )
22376 
 
5386 phani.kuma 22377 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22378 
    self.referenceId = referenceId
22379 
    self.isRefund = isRefund
4600 varun.gupt 22380 
 
22381 
  def read(self, iprot):
22382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22384 
      return
22385 
    iprot.readStructBegin()
22386 
    while True:
22387 
      (fname, ftype, fid) = iprot.readFieldBegin()
22388 
      if ftype == TType.STOP:
22389 
        break
22390 
      if fid == 1:
22391 
        if ftype == TType.I64:
5189 varun.gupt 22392 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22393 
        else:
22394 
          iprot.skip(ftype)
5189 varun.gupt 22395 
      elif fid == 2:
22396 
        if ftype == TType.BOOL:
22397 
          self.isRefund = iprot.readBool();
22398 
        else:
22399 
          iprot.skip(ftype)
4600 varun.gupt 22400 
      else:
22401 
        iprot.skip(ftype)
22402 
      iprot.readFieldEnd()
22403 
    iprot.readStructEnd()
22404 
 
22405 
  def write(self, oprot):
22406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22408 
      return
5386 phani.kuma 22409 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22410 
    if self.referenceId is not None:
22411 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22412 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22413 
      oprot.writeFieldEnd()
5386 phani.kuma 22414 
    if self.isRefund is not None:
22415 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22416 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22417 
      oprot.writeFieldEnd()
5386 phani.kuma 22418 
    oprot.writeFieldStop()
22419 
    oprot.writeStructEnd()
22420 
 
22421 
  def validate(self):
22422 
    return
22423 
 
22424 
 
22425 
  def __repr__(self):
22426 
    L = ['%s=%r' % (key, value)
22427 
      for key, value in self.__dict__.iteritems()]
22428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22429 
 
22430 
  def __eq__(self, other):
22431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22432 
 
22433 
  def __ne__(self, other):
22434 
    return not (self == other)
22435 
 
22436 
class getSettlementForPrepaid_result:
22437 
  """
22438 
  Attributes:
22439 
   - success
22440 
   - ex
22441 
  """
22442 
 
22443 
  thrift_spec = (
22444 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22446 
  )
22447 
 
22448 
  def __init__(self, success=None, ex=None,):
22449 
    self.success = success
22450 
    self.ex = ex
22451 
 
22452 
  def read(self, iprot):
22453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22455 
      return
22456 
    iprot.readStructBegin()
22457 
    while True:
22458 
      (fname, ftype, fid) = iprot.readFieldBegin()
22459 
      if ftype == TType.STOP:
22460 
        break
22461 
      if fid == 0:
22462 
        if ftype == TType.STRUCT:
22463 
          self.success = PaymentSettlement()
22464 
          self.success.read(iprot)
22465 
        else:
22466 
          iprot.skip(ftype)
22467 
      elif fid == 1:
22468 
        if ftype == TType.STRUCT:
22469 
          self.ex = TransactionServiceException()
22470 
          self.ex.read(iprot)
22471 
        else:
22472 
          iprot.skip(ftype)
22473 
      else:
22474 
        iprot.skip(ftype)
22475 
      iprot.readFieldEnd()
22476 
    iprot.readStructEnd()
22477 
 
22478 
  def write(self, oprot):
22479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22481 
      return
22482 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22483 
    if self.success is not None:
22484 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22485 
      self.success.write(oprot)
22486 
      oprot.writeFieldEnd()
22487 
    if self.ex is not None:
22488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22489 
      self.ex.write(oprot)
22490 
      oprot.writeFieldEnd()
22491 
    oprot.writeFieldStop()
22492 
    oprot.writeStructEnd()
22493 
 
22494 
  def validate(self):
22495 
    return
22496 
 
22497 
 
22498 
  def __repr__(self):
22499 
    L = ['%s=%r' % (key, value)
22500 
      for key, value in self.__dict__.iteritems()]
22501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22502 
 
22503 
  def __eq__(self, other):
22504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22505 
 
22506 
  def __ne__(self, other):
22507 
    return not (self == other)
22508 
 
22509 
class getSettlementForCod_args:
22510 
  """
22511 
  Attributes:
22512 
   - orderId
22513 
   - isRefund
22514 
  """
22515 
 
22516 
  thrift_spec = (
22517 
    None, # 0
22518 
    (1, TType.I64, 'orderId', None, None, ), # 1
22519 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22520 
  )
22521 
 
22522 
  def __init__(self, orderId=None, isRefund=None,):
22523 
    self.orderId = orderId
22524 
    self.isRefund = isRefund
22525 
 
22526 
  def read(self, iprot):
22527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22529 
      return
22530 
    iprot.readStructBegin()
22531 
    while True:
22532 
      (fname, ftype, fid) = iprot.readFieldBegin()
22533 
      if ftype == TType.STOP:
22534 
        break
22535 
      if fid == 1:
22536 
        if ftype == TType.I64:
22537 
          self.orderId = iprot.readI64();
22538 
        else:
22539 
          iprot.skip(ftype)
22540 
      elif fid == 2:
22541 
        if ftype == TType.BOOL:
22542 
          self.isRefund = iprot.readBool();
22543 
        else:
22544 
          iprot.skip(ftype)
22545 
      else:
22546 
        iprot.skip(ftype)
22547 
      iprot.readFieldEnd()
22548 
    iprot.readStructEnd()
22549 
 
22550 
  def write(self, oprot):
22551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22553 
      return
22554 
    oprot.writeStructBegin('getSettlementForCod_args')
22555 
    if self.orderId is not None:
22556 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22557 
      oprot.writeI64(self.orderId)
22558 
      oprot.writeFieldEnd()
5189 varun.gupt 22559 
    if self.isRefund is not None:
5386 phani.kuma 22560 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22561 
      oprot.writeBool(self.isRefund)
22562 
      oprot.writeFieldEnd()
4600 varun.gupt 22563 
    oprot.writeFieldStop()
22564 
    oprot.writeStructEnd()
22565 
 
22566 
  def validate(self):
22567 
    return
22568 
 
22569 
 
22570 
  def __repr__(self):
22571 
    L = ['%s=%r' % (key, value)
22572 
      for key, value in self.__dict__.iteritems()]
22573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22574 
 
22575 
  def __eq__(self, other):
22576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22577 
 
22578 
  def __ne__(self, other):
22579 
    return not (self == other)
22580 
 
5386 phani.kuma 22581 
class getSettlementForCod_result:
4600 varun.gupt 22582 
  """
22583 
  Attributes:
22584 
   - success
22585 
   - ex
22586 
  """
22587 
 
22588 
  thrift_spec = (
22589 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22591 
  )
22592 
 
22593 
  def __init__(self, success=None, ex=None,):
22594 
    self.success = success
22595 
    self.ex = ex
22596 
 
22597 
  def read(self, iprot):
22598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22600 
      return
22601 
    iprot.readStructBegin()
22602 
    while True:
22603 
      (fname, ftype, fid) = iprot.readFieldBegin()
22604 
      if ftype == TType.STOP:
22605 
        break
22606 
      if fid == 0:
22607 
        if ftype == TType.STRUCT:
22608 
          self.success = PaymentSettlement()
22609 
          self.success.read(iprot)
22610 
        else:
22611 
          iprot.skip(ftype)
22612 
      elif fid == 1:
22613 
        if ftype == TType.STRUCT:
22614 
          self.ex = TransactionServiceException()
22615 
          self.ex.read(iprot)
22616 
        else:
22617 
          iprot.skip(ftype)
22618 
      else:
22619 
        iprot.skip(ftype)
22620 
      iprot.readFieldEnd()
22621 
    iprot.readStructEnd()
22622 
 
22623 
  def write(self, oprot):
22624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22626 
      return
5386 phani.kuma 22627 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22628 
    if self.success is not None:
22629 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22630 
      self.success.write(oprot)
22631 
      oprot.writeFieldEnd()
22632 
    if self.ex is not None:
22633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22634 
      self.ex.write(oprot)
22635 
      oprot.writeFieldEnd()
22636 
    oprot.writeFieldStop()
22637 
    oprot.writeStructEnd()
22638 
 
22639 
  def validate(self):
22640 
    return
22641 
 
22642 
 
22643 
  def __repr__(self):
22644 
    L = ['%s=%r' % (key, value)
22645 
      for key, value in self.__dict__.iteritems()]
22646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22647 
 
22648 
  def __eq__(self, other):
22649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22650 
 
22651 
  def __ne__(self, other):
22652 
    return not (self == other)
22653 
 
22654 
class getEBSSettlementSummaries_args:
22655 
 
22656 
  thrift_spec = (
22657 
  )
22658 
 
22659 
  def read(self, iprot):
22660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22662 
      return
22663 
    iprot.readStructBegin()
22664 
    while True:
22665 
      (fname, ftype, fid) = iprot.readFieldBegin()
22666 
      if ftype == TType.STOP:
22667 
        break
22668 
      else:
22669 
        iprot.skip(ftype)
22670 
      iprot.readFieldEnd()
22671 
    iprot.readStructEnd()
22672 
 
22673 
  def write(self, oprot):
22674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22676 
      return
22677 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22678 
    oprot.writeFieldStop()
22679 
    oprot.writeStructEnd()
22680 
 
22681 
  def validate(self):
22682 
    return
22683 
 
22684 
 
22685 
  def __repr__(self):
22686 
    L = ['%s=%r' % (key, value)
22687 
      for key, value in self.__dict__.iteritems()]
22688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22689 
 
22690 
  def __eq__(self, other):
22691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22692 
 
22693 
  def __ne__(self, other):
22694 
    return not (self == other)
22695 
 
22696 
class getEBSSettlementSummaries_result:
22697 
  """
22698 
  Attributes:
22699 
   - success
22700 
   - ex
22701 
  """
22702 
 
22703 
  thrift_spec = (
22704 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22706 
  )
22707 
 
22708 
  def __init__(self, success=None, ex=None,):
22709 
    self.success = success
22710 
    self.ex = ex
22711 
 
22712 
  def read(self, iprot):
22713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22715 
      return
22716 
    iprot.readStructBegin()
22717 
    while True:
22718 
      (fname, ftype, fid) = iprot.readFieldBegin()
22719 
      if ftype == TType.STOP:
22720 
        break
22721 
      if fid == 0:
22722 
        if ftype == TType.MAP:
22723 
          self.success = {}
6000 mandeep.dh 22724 
          (_ktype519, _vtype520, _size518 ) = iprot.readMapBegin()
22725 
          for _i522 in xrange(_size518):
22726 
            _key523 = iprot.readI64();
22727 
            _val524 = iprot.readString();
22728 
            self.success[_key523] = _val524
4600 varun.gupt 22729 
          iprot.readMapEnd()
22730 
        else:
22731 
          iprot.skip(ftype)
22732 
      elif fid == 1:
22733 
        if ftype == TType.STRUCT:
22734 
          self.ex = TransactionServiceException()
22735 
          self.ex.read(iprot)
22736 
        else:
22737 
          iprot.skip(ftype)
22738 
      else:
22739 
        iprot.skip(ftype)
22740 
      iprot.readFieldEnd()
22741 
    iprot.readStructEnd()
22742 
 
22743 
  def write(self, oprot):
22744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22746 
      return
22747 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22748 
    if self.success is not None:
22749 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22750 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6000 mandeep.dh 22751 
      for kiter525,viter526 in self.success.items():
22752 
        oprot.writeI64(kiter525)
22753 
        oprot.writeString(viter526)
4600 varun.gupt 22754 
      oprot.writeMapEnd()
22755 
      oprot.writeFieldEnd()
22756 
    if self.ex is not None:
22757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22758 
      self.ex.write(oprot)
22759 
      oprot.writeFieldEnd()
22760 
    oprot.writeFieldStop()
22761 
    oprot.writeStructEnd()
22762 
 
22763 
  def validate(self):
22764 
    return
22765 
 
22766 
 
22767 
  def __repr__(self):
22768 
    L = ['%s=%r' % (key, value)
22769 
      for key, value in self.__dict__.iteritems()]
22770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22771 
 
22772 
  def __eq__(self, other):
22773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22774 
 
22775 
  def __ne__(self, other):
22776 
    return not (self == other)
22777 
 
22778 
class markEBSSettlementUploaded_args:
22779 
  """
22780 
  Attributes:
22781 
   - settlementId
22782 
  """
22783 
 
22784 
  thrift_spec = (
22785 
    None, # 0
22786 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22787 
  )
22788 
 
22789 
  def __init__(self, settlementId=None,):
22790 
    self.settlementId = settlementId
22791 
 
22792 
  def read(self, iprot):
22793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22795 
      return
22796 
    iprot.readStructBegin()
22797 
    while True:
22798 
      (fname, ftype, fid) = iprot.readFieldBegin()
22799 
      if ftype == TType.STOP:
22800 
        break
22801 
      if fid == 1:
22802 
        if ftype == TType.I64:
22803 
          self.settlementId = iprot.readI64();
22804 
        else:
22805 
          iprot.skip(ftype)
22806 
      else:
22807 
        iprot.skip(ftype)
22808 
      iprot.readFieldEnd()
22809 
    iprot.readStructEnd()
22810 
 
22811 
  def write(self, oprot):
22812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22814 
      return
22815 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22816 
    if self.settlementId is not None:
22817 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22818 
      oprot.writeI64(self.settlementId)
22819 
      oprot.writeFieldEnd()
22820 
    oprot.writeFieldStop()
22821 
    oprot.writeStructEnd()
22822 
 
22823 
  def validate(self):
22824 
    return
22825 
 
22826 
 
22827 
  def __repr__(self):
22828 
    L = ['%s=%r' % (key, value)
22829 
      for key, value in self.__dict__.iteritems()]
22830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22831 
 
22832 
  def __eq__(self, other):
22833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22834 
 
22835 
  def __ne__(self, other):
22836 
    return not (self == other)
22837 
 
22838 
class markEBSSettlementUploaded_result:
22839 
  """
22840 
  Attributes:
22841 
   - ex
22842 
  """
22843 
 
22844 
  thrift_spec = (
22845 
    None, # 0
22846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22847 
  )
22848 
 
22849 
  def __init__(self, ex=None,):
22850 
    self.ex = ex
22851 
 
22852 
  def read(self, iprot):
22853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22855 
      return
22856 
    iprot.readStructBegin()
22857 
    while True:
22858 
      (fname, ftype, fid) = iprot.readFieldBegin()
22859 
      if ftype == TType.STOP:
22860 
        break
22861 
      if fid == 1:
22862 
        if ftype == TType.STRUCT:
22863 
          self.ex = TransactionServiceException()
22864 
          self.ex.read(iprot)
22865 
        else:
22866 
          iprot.skip(ftype)
22867 
      else:
22868 
        iprot.skip(ftype)
22869 
      iprot.readFieldEnd()
22870 
    iprot.readStructEnd()
22871 
 
22872 
  def write(self, oprot):
22873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22875 
      return
22876 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22877 
    if self.ex is not None:
22878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22879 
      self.ex.write(oprot)
22880 
      oprot.writeFieldEnd()
22881 
    oprot.writeFieldStop()
22882 
    oprot.writeStructEnd()
22883 
 
22884 
  def validate(self):
22885 
    return
22886 
 
22887 
 
22888 
  def __repr__(self):
22889 
    L = ['%s=%r' % (key, value)
22890 
      for key, value in self.__dict__.iteritems()]
22891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22892 
 
22893 
  def __eq__(self, other):
22894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22895 
 
22896 
  def __ne__(self, other):
22897 
    return not (self == other)
22898 
 
22899 
class getEBSSettlementDate_args:
22900 
  """
22901 
  Attributes:
22902 
   - settlementId
22903 
  """
22904 
 
22905 
  thrift_spec = (
22906 
    None, # 0
22907 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22908 
  )
22909 
 
22910 
  def __init__(self, settlementId=None,):
22911 
    self.settlementId = settlementId
22912 
 
22913 
  def read(self, iprot):
22914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22916 
      return
22917 
    iprot.readStructBegin()
22918 
    while True:
22919 
      (fname, ftype, fid) = iprot.readFieldBegin()
22920 
      if ftype == TType.STOP:
22921 
        break
22922 
      if fid == 1:
22923 
        if ftype == TType.I64:
22924 
          self.settlementId = iprot.readI64();
22925 
        else:
22926 
          iprot.skip(ftype)
22927 
      else:
22928 
        iprot.skip(ftype)
22929 
      iprot.readFieldEnd()
22930 
    iprot.readStructEnd()
22931 
 
22932 
  def write(self, oprot):
22933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22935 
      return
22936 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22937 
    if self.settlementId is not None:
22938 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22939 
      oprot.writeI64(self.settlementId)
22940 
      oprot.writeFieldEnd()
22941 
    oprot.writeFieldStop()
22942 
    oprot.writeStructEnd()
22943 
 
22944 
  def validate(self):
22945 
    return
22946 
 
22947 
 
22948 
  def __repr__(self):
22949 
    L = ['%s=%r' % (key, value)
22950 
      for key, value in self.__dict__.iteritems()]
22951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22952 
 
22953 
  def __eq__(self, other):
22954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22955 
 
22956 
  def __ne__(self, other):
22957 
    return not (self == other)
22958 
 
22959 
class getEBSSettlementDate_result:
22960 
  """
22961 
  Attributes:
22962 
   - success
22963 
   - ex
22964 
  """
22965 
 
22966 
  thrift_spec = (
22967 
    (0, TType.I64, 'success', None, None, ), # 0
22968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22969 
  )
22970 
 
22971 
  def __init__(self, success=None, ex=None,):
22972 
    self.success = success
22973 
    self.ex = ex
22974 
 
22975 
  def read(self, iprot):
22976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22978 
      return
22979 
    iprot.readStructBegin()
22980 
    while True:
22981 
      (fname, ftype, fid) = iprot.readFieldBegin()
22982 
      if ftype == TType.STOP:
22983 
        break
22984 
      if fid == 0:
22985 
        if ftype == TType.I64:
22986 
          self.success = iprot.readI64();
22987 
        else:
22988 
          iprot.skip(ftype)
22989 
      elif fid == 1:
22990 
        if ftype == TType.STRUCT:
22991 
          self.ex = TransactionServiceException()
22992 
          self.ex.read(iprot)
22993 
        else:
22994 
          iprot.skip(ftype)
22995 
      else:
22996 
        iprot.skip(ftype)
22997 
      iprot.readFieldEnd()
22998 
    iprot.readStructEnd()
22999 
 
23000 
  def write(self, oprot):
23001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23003 
      return
23004 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23005 
    if self.success is not None:
23006 
      oprot.writeFieldBegin('success', TType.I64, 0)
23007 
      oprot.writeI64(self.success)
23008 
      oprot.writeFieldEnd()
23009 
    if self.ex is not None:
23010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23011 
      self.ex.write(oprot)
23012 
      oprot.writeFieldEnd()
23013 
    oprot.writeFieldStop()
23014 
    oprot.writeStructEnd()
23015 
 
23016 
  def validate(self):
23017 
    return
23018 
 
23019 
 
23020 
  def __repr__(self):
23021 
    L = ['%s=%r' % (key, value)
23022 
      for key, value in self.__dict__.iteritems()]
23023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23024 
 
23025 
  def __eq__(self, other):
23026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23027 
 
23028 
  def __ne__(self, other):
23029 
    return not (self == other)
4715 varun.gupt 23030 
 
23031 
class getSettlementsByDate_args:
23032 
  """
23033 
  Attributes:
23034 
   - settlementDateFrom
23035 
   - settlementDateTo
23036 
   - isRefund
23037 
  """
23038 
 
23039 
  thrift_spec = (
23040 
    None, # 0
23041 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23042 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23043 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23044 
  )
23045 
 
23046 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23047 
    self.settlementDateFrom = settlementDateFrom
23048 
    self.settlementDateTo = settlementDateTo
23049 
    self.isRefund = isRefund
23050 
 
23051 
  def read(self, iprot):
23052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23054 
      return
23055 
    iprot.readStructBegin()
23056 
    while True:
23057 
      (fname, ftype, fid) = iprot.readFieldBegin()
23058 
      if ftype == TType.STOP:
23059 
        break
23060 
      if fid == 1:
23061 
        if ftype == TType.I64:
23062 
          self.settlementDateFrom = iprot.readI64();
23063 
        else:
23064 
          iprot.skip(ftype)
23065 
      elif fid == 2:
23066 
        if ftype == TType.I64:
23067 
          self.settlementDateTo = iprot.readI64();
23068 
        else:
23069 
          iprot.skip(ftype)
23070 
      elif fid == 3:
23071 
        if ftype == TType.BOOL:
23072 
          self.isRefund = iprot.readBool();
23073 
        else:
23074 
          iprot.skip(ftype)
23075 
      else:
23076 
        iprot.skip(ftype)
23077 
      iprot.readFieldEnd()
23078 
    iprot.readStructEnd()
23079 
 
23080 
  def write(self, oprot):
23081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23083 
      return
23084 
    oprot.writeStructBegin('getSettlementsByDate_args')
23085 
    if self.settlementDateFrom is not None:
23086 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23087 
      oprot.writeI64(self.settlementDateFrom)
23088 
      oprot.writeFieldEnd()
23089 
    if self.settlementDateTo is not None:
23090 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23091 
      oprot.writeI64(self.settlementDateTo)
23092 
      oprot.writeFieldEnd()
23093 
    if self.isRefund is not None:
23094 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23095 
      oprot.writeBool(self.isRefund)
23096 
      oprot.writeFieldEnd()
23097 
    oprot.writeFieldStop()
23098 
    oprot.writeStructEnd()
23099 
 
23100 
  def validate(self):
23101 
    return
23102 
 
23103 
 
23104 
  def __repr__(self):
23105 
    L = ['%s=%r' % (key, value)
23106 
      for key, value in self.__dict__.iteritems()]
23107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23108 
 
23109 
  def __eq__(self, other):
23110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23111 
 
23112 
  def __ne__(self, other):
23113 
    return not (self == other)
23114 
 
23115 
class getSettlementsByDate_result:
23116 
  """
23117 
  Attributes:
23118 
   - success
23119 
   - ex
23120 
  """
23121 
 
23122 
  thrift_spec = (
23123 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23125 
  )
23126 
 
23127 
  def __init__(self, success=None, ex=None,):
23128 
    self.success = success
23129 
    self.ex = ex
23130 
 
23131 
  def read(self, iprot):
23132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23134 
      return
23135 
    iprot.readStructBegin()
23136 
    while True:
23137 
      (fname, ftype, fid) = iprot.readFieldBegin()
23138 
      if ftype == TType.STOP:
23139 
        break
23140 
      if fid == 0:
23141 
        if ftype == TType.LIST:
23142 
          self.success = []
6000 mandeep.dh 23143 
          (_etype530, _size527) = iprot.readListBegin()
23144 
          for _i531 in xrange(_size527):
23145 
            _elem532 = PaymentSettlement()
23146 
            _elem532.read(iprot)
23147 
            self.success.append(_elem532)
4715 varun.gupt 23148 
          iprot.readListEnd()
23149 
        else:
23150 
          iprot.skip(ftype)
23151 
      elif fid == 1:
23152 
        if ftype == TType.STRUCT:
23153 
          self.ex = TransactionServiceException()
23154 
          self.ex.read(iprot)
23155 
        else:
23156 
          iprot.skip(ftype)
23157 
      else:
23158 
        iprot.skip(ftype)
23159 
      iprot.readFieldEnd()
23160 
    iprot.readStructEnd()
23161 
 
23162 
  def write(self, oprot):
23163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23165 
      return
23166 
    oprot.writeStructBegin('getSettlementsByDate_result')
23167 
    if self.success is not None:
23168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 23170 
      for iter533 in self.success:
23171 
        iter533.write(oprot)
4715 varun.gupt 23172 
      oprot.writeListEnd()
23173 
      oprot.writeFieldEnd()
23174 
    if self.ex is not None:
23175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23176 
      self.ex.write(oprot)
23177 
      oprot.writeFieldEnd()
23178 
    oprot.writeFieldStop()
23179 
    oprot.writeStructEnd()
23180 
 
23181 
  def validate(self):
23182 
    return
23183 
 
23184 
 
23185 
  def __repr__(self):
23186 
    L = ['%s=%r' % (key, value)
23187 
      for key, value in self.__dict__.iteritems()]
23188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23189 
 
23190 
  def __eq__(self, other):
23191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23192 
 
23193 
  def __ne__(self, other):
23194 
    return not (self == other)
23195 
 
23196 
class getReshippedOrderIds_args:
23197 
  """
23198 
  Attributes:
23199 
   - orderIds
23200 
  """
23201 
 
23202 
  thrift_spec = (
23203 
    None, # 0
23204 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23205 
  )
23206 
 
23207 
  def __init__(self, orderIds=None,):
23208 
    self.orderIds = orderIds
23209 
 
23210 
  def read(self, iprot):
23211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23213 
      return
23214 
    iprot.readStructBegin()
23215 
    while True:
23216 
      (fname, ftype, fid) = iprot.readFieldBegin()
23217 
      if ftype == TType.STOP:
23218 
        break
23219 
      if fid == 1:
23220 
        if ftype == TType.LIST:
23221 
          self.orderIds = []
6000 mandeep.dh 23222 
          (_etype537, _size534) = iprot.readListBegin()
23223 
          for _i538 in xrange(_size534):
23224 
            _elem539 = iprot.readI64();
23225 
            self.orderIds.append(_elem539)
4715 varun.gupt 23226 
          iprot.readListEnd()
23227 
        else:
23228 
          iprot.skip(ftype)
23229 
      else:
23230 
        iprot.skip(ftype)
23231 
      iprot.readFieldEnd()
23232 
    iprot.readStructEnd()
23233 
 
23234 
  def write(self, oprot):
23235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23237 
      return
23238 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23239 
    if self.orderIds is not None:
23240 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23241 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 23242 
      for iter540 in self.orderIds:
23243 
        oprot.writeI64(iter540)
4715 varun.gupt 23244 
      oprot.writeListEnd()
23245 
      oprot.writeFieldEnd()
23246 
    oprot.writeFieldStop()
23247 
    oprot.writeStructEnd()
23248 
 
23249 
  def validate(self):
23250 
    return
23251 
 
23252 
 
23253 
  def __repr__(self):
23254 
    L = ['%s=%r' % (key, value)
23255 
      for key, value in self.__dict__.iteritems()]
23256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23257 
 
23258 
  def __eq__(self, other):
23259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23260 
 
23261 
  def __ne__(self, other):
23262 
    return not (self == other)
23263 
 
23264 
class getReshippedOrderIds_result:
23265 
  """
23266 
  Attributes:
23267 
   - success
23268 
   - ex
23269 
  """
23270 
 
23271 
  thrift_spec = (
23272 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23274 
  )
23275 
 
23276 
  def __init__(self, success=None, ex=None,):
23277 
    self.success = success
23278 
    self.ex = ex
23279 
 
23280 
  def read(self, iprot):
23281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23283 
      return
23284 
    iprot.readStructBegin()
23285 
    while True:
23286 
      (fname, ftype, fid) = iprot.readFieldBegin()
23287 
      if ftype == TType.STOP:
23288 
        break
23289 
      if fid == 0:
23290 
        if ftype == TType.LIST:
23291 
          self.success = []
6000 mandeep.dh 23292 
          (_etype544, _size541) = iprot.readListBegin()
23293 
          for _i545 in xrange(_size541):
23294 
            _elem546 = iprot.readI64();
23295 
            self.success.append(_elem546)
4715 varun.gupt 23296 
          iprot.readListEnd()
23297 
        else:
23298 
          iprot.skip(ftype)
23299 
      elif fid == 1:
23300 
        if ftype == TType.STRUCT:
23301 
          self.ex = TransactionServiceException()
23302 
          self.ex.read(iprot)
23303 
        else:
23304 
          iprot.skip(ftype)
23305 
      else:
23306 
        iprot.skip(ftype)
23307 
      iprot.readFieldEnd()
23308 
    iprot.readStructEnd()
23309 
 
23310 
  def write(self, oprot):
23311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23313 
      return
23314 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23315 
    if self.success is not None:
23316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23317 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 23318 
      for iter547 in self.success:
23319 
        oprot.writeI64(iter547)
4715 varun.gupt 23320 
      oprot.writeListEnd()
23321 
      oprot.writeFieldEnd()
23322 
    if self.ex is not None:
23323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23324 
      self.ex.write(oprot)
23325 
      oprot.writeFieldEnd()
23326 
    oprot.writeFieldStop()
23327 
    oprot.writeStructEnd()
23328 
 
23329 
  def validate(self):
23330 
    return
23331 
 
23332 
 
23333 
  def __repr__(self):
23334 
    L = ['%s=%r' % (key, value)
23335 
      for key, value in self.__dict__.iteritems()]
23336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23337 
 
23338 
  def __eq__(self, other):
23339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23340 
 
23341 
  def __ne__(self, other):
23342 
    return not (self == other)
4757 mandeep.dh 23343 
 
5481 phani.kuma 23344 
class getBilledOrders_args:
4875 varun.gupt 23345 
  """
23346 
  Attributes:
23347 
   - vendorId
5481 phani.kuma 23348 
   - onlyVendorNotPaid
23349 
   - billingDateFrom
23350 
   - billingDateTo
4875 varun.gupt 23351 
  """
23352 
 
23353 
  thrift_spec = (
23354 
    None, # 0
23355 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23356 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23357 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23358 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23359 
  )
23360 
 
5481 phani.kuma 23361 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23362 
    self.vendorId = vendorId
5481 phani.kuma 23363 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23364 
    self.billingDateFrom = billingDateFrom
23365 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23366 
 
23367 
  def read(self, iprot):
23368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23370 
      return
23371 
    iprot.readStructBegin()
23372 
    while True:
23373 
      (fname, ftype, fid) = iprot.readFieldBegin()
23374 
      if ftype == TType.STOP:
23375 
        break
23376 
      if fid == 1:
23377 
        if ftype == TType.I64:
23378 
          self.vendorId = iprot.readI64();
23379 
        else:
23380 
          iprot.skip(ftype)
5481 phani.kuma 23381 
      elif fid == 2:
23382 
        if ftype == TType.BOOL:
23383 
          self.onlyVendorNotPaid = iprot.readBool();
23384 
        else:
23385 
          iprot.skip(ftype)
23386 
      elif fid == 3:
23387 
        if ftype == TType.I64:
23388 
          self.billingDateFrom = iprot.readI64();
23389 
        else:
23390 
          iprot.skip(ftype)
23391 
      elif fid == 4:
23392 
        if ftype == TType.I64:
23393 
          self.billingDateTo = iprot.readI64();
23394 
        else:
23395 
          iprot.skip(ftype)
4875 varun.gupt 23396 
      else:
23397 
        iprot.skip(ftype)
23398 
      iprot.readFieldEnd()
23399 
    iprot.readStructEnd()
23400 
 
23401 
  def write(self, oprot):
23402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23404 
      return
5481 phani.kuma 23405 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23406 
    if self.vendorId is not None:
23407 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23408 
      oprot.writeI64(self.vendorId)
23409 
      oprot.writeFieldEnd()
5481 phani.kuma 23410 
    if self.onlyVendorNotPaid is not None:
23411 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23412 
      oprot.writeBool(self.onlyVendorNotPaid)
23413 
      oprot.writeFieldEnd()
23414 
    if self.billingDateFrom is not None:
23415 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23416 
      oprot.writeI64(self.billingDateFrom)
23417 
      oprot.writeFieldEnd()
23418 
    if self.billingDateTo is not None:
23419 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23420 
      oprot.writeI64(self.billingDateTo)
23421 
      oprot.writeFieldEnd()
4875 varun.gupt 23422 
    oprot.writeFieldStop()
23423 
    oprot.writeStructEnd()
23424 
 
23425 
  def validate(self):
23426 
    return
23427 
 
23428 
 
23429 
  def __repr__(self):
23430 
    L = ['%s=%r' % (key, value)
23431 
      for key, value in self.__dict__.iteritems()]
23432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23433 
 
23434 
  def __eq__(self, other):
23435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23436 
 
23437 
  def __ne__(self, other):
23438 
    return not (self == other)
23439 
 
5481 phani.kuma 23440 
class getBilledOrders_result:
4875 varun.gupt 23441 
  """
23442 
  Attributes:
23443 
   - success
23444 
   - ex
23445 
  """
23446 
 
23447 
  thrift_spec = (
23448 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23450 
  )
23451 
 
23452 
  def __init__(self, success=None, ex=None,):
23453 
    self.success = success
23454 
    self.ex = ex
23455 
 
23456 
  def read(self, iprot):
23457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23459 
      return
23460 
    iprot.readStructBegin()
23461 
    while True:
23462 
      (fname, ftype, fid) = iprot.readFieldBegin()
23463 
      if ftype == TType.STOP:
23464 
        break
23465 
      if fid == 0:
23466 
        if ftype == TType.LIST:
23467 
          self.success = []
6000 mandeep.dh 23468 
          (_etype551, _size548) = iprot.readListBegin()
23469 
          for _i552 in xrange(_size548):
23470 
            _elem553 = Order()
23471 
            _elem553.read(iprot)
23472 
            self.success.append(_elem553)
4875 varun.gupt 23473 
          iprot.readListEnd()
23474 
        else:
23475 
          iprot.skip(ftype)
23476 
      elif fid == 1:
23477 
        if ftype == TType.STRUCT:
23478 
          self.ex = TransactionServiceException()
23479 
          self.ex.read(iprot)
23480 
        else:
23481 
          iprot.skip(ftype)
23482 
      else:
23483 
        iprot.skip(ftype)
23484 
      iprot.readFieldEnd()
23485 
    iprot.readStructEnd()
23486 
 
23487 
  def write(self, oprot):
23488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23490 
      return
5481 phani.kuma 23491 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23492 
    if self.success is not None:
23493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 23495 
      for iter554 in self.success:
23496 
        iter554.write(oprot)
4875 varun.gupt 23497 
      oprot.writeListEnd()
23498 
      oprot.writeFieldEnd()
23499 
    if self.ex is not None:
23500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23501 
      self.ex.write(oprot)
23502 
      oprot.writeFieldEnd()
23503 
    oprot.writeFieldStop()
23504 
    oprot.writeStructEnd()
23505 
 
23506 
  def validate(self):
23507 
    return
23508 
 
23509 
 
23510 
  def __repr__(self):
23511 
    L = ['%s=%r' % (key, value)
23512 
      for key, value in self.__dict__.iteritems()]
23513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23514 
 
23515 
  def __eq__(self, other):
23516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23517 
 
23518 
  def __ne__(self, other):
23519 
    return not (self == other)
5031 varun.gupt 23520 
 
23521 
class getStatusDistributionOfOrders_args:
23522 
  """
23523 
  Attributes:
23524 
   - startDate
23525 
   - endDate
23526 
  """
23527 
 
23528 
  thrift_spec = (
23529 
    None, # 0
23530 
    (1, TType.I64, 'startDate', None, None, ), # 1
23531 
    (2, TType.I64, 'endDate', None, None, ), # 2
23532 
  )
23533 
 
23534 
  def __init__(self, startDate=None, endDate=None,):
23535 
    self.startDate = startDate
23536 
    self.endDate = endDate
23537 
 
23538 
  def read(self, iprot):
23539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23541 
      return
23542 
    iprot.readStructBegin()
23543 
    while True:
23544 
      (fname, ftype, fid) = iprot.readFieldBegin()
23545 
      if ftype == TType.STOP:
23546 
        break
23547 
      if fid == 1:
23548 
        if ftype == TType.I64:
23549 
          self.startDate = iprot.readI64();
23550 
        else:
23551 
          iprot.skip(ftype)
23552 
      elif fid == 2:
23553 
        if ftype == TType.I64:
23554 
          self.endDate = iprot.readI64();
23555 
        else:
23556 
          iprot.skip(ftype)
23557 
      else:
23558 
        iprot.skip(ftype)
23559 
      iprot.readFieldEnd()
23560 
    iprot.readStructEnd()
23561 
 
23562 
  def write(self, oprot):
23563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23565 
      return
23566 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23567 
    if self.startDate is not None:
23568 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23569 
      oprot.writeI64(self.startDate)
23570 
      oprot.writeFieldEnd()
23571 
    if self.endDate is not None:
23572 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23573 
      oprot.writeI64(self.endDate)
23574 
      oprot.writeFieldEnd()
23575 
    oprot.writeFieldStop()
23576 
    oprot.writeStructEnd()
23577 
 
23578 
  def validate(self):
23579 
    return
23580 
 
23581 
 
23582 
  def __repr__(self):
23583 
    L = ['%s=%r' % (key, value)
23584 
      for key, value in self.__dict__.iteritems()]
23585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23586 
 
23587 
  def __eq__(self, other):
23588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23589 
 
23590 
  def __ne__(self, other):
23591 
    return not (self == other)
23592 
 
23593 
class getStatusDistributionOfOrders_result:
23594 
  """
23595 
  Attributes:
23596 
   - success
23597 
   - ex
23598 
  """
23599 
 
23600 
  thrift_spec = (
23601 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23603 
  )
23604 
 
23605 
  def __init__(self, success=None, ex=None,):
23606 
    self.success = success
23607 
    self.ex = ex
23608 
 
23609 
  def read(self, iprot):
23610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23612 
      return
23613 
    iprot.readStructBegin()
23614 
    while True:
23615 
      (fname, ftype, fid) = iprot.readFieldBegin()
23616 
      if ftype == TType.STOP:
23617 
        break
23618 
      if fid == 0:
23619 
        if ftype == TType.MAP:
23620 
          self.success = {}
6000 mandeep.dh 23621 
          (_ktype556, _vtype557, _size555 ) = iprot.readMapBegin()
23622 
          for _i559 in xrange(_size555):
23623 
            _key560 = iprot.readI64();
23624 
            _val561 = iprot.readI64();
23625 
            self.success[_key560] = _val561
5031 varun.gupt 23626 
          iprot.readMapEnd()
23627 
        else:
23628 
          iprot.skip(ftype)
23629 
      elif fid == 1:
23630 
        if ftype == TType.STRUCT:
23631 
          self.ex = TransactionServiceException()
23632 
          self.ex.read(iprot)
23633 
        else:
23634 
          iprot.skip(ftype)
23635 
      else:
23636 
        iprot.skip(ftype)
23637 
      iprot.readFieldEnd()
23638 
    iprot.readStructEnd()
23639 
 
23640 
  def write(self, oprot):
23641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23643 
      return
23644 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23645 
    if self.success is not None:
23646 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23647 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6000 mandeep.dh 23648 
      for kiter562,viter563 in self.success.items():
23649 
        oprot.writeI64(kiter562)
23650 
        oprot.writeI64(viter563)
5031 varun.gupt 23651 
      oprot.writeMapEnd()
23652 
      oprot.writeFieldEnd()
23653 
    if self.ex is not None:
23654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23655 
      self.ex.write(oprot)
23656 
      oprot.writeFieldEnd()
23657 
    oprot.writeFieldStop()
23658 
    oprot.writeStructEnd()
23659 
 
23660 
  def validate(self):
23661 
    return
23662 
 
23663 
 
23664 
  def __repr__(self):
23665 
    L = ['%s=%r' % (key, value)
23666 
      for key, value in self.__dict__.iteritems()]
23667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23668 
 
23669 
  def __eq__(self, other):
23670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23671 
 
23672 
  def __ne__(self, other):
23673 
    return not (self == other)
5067 varun.gupt 23674 
 
23675 
class getOrderIdsForStatus_args:
23676 
  """
23677 
  Attributes:
23678 
   - status
23679 
   - startDatetime
23680 
   - endDatetime
23681 
  """
23682 
 
23683 
  thrift_spec = (
23684 
    None, # 0
23685 
    (1, TType.I64, 'status', None, None, ), # 1
23686 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23687 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23688 
  )
23689 
 
23690 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23691 
    self.status = status
23692 
    self.startDatetime = startDatetime
23693 
    self.endDatetime = endDatetime
23694 
 
23695 
  def read(self, iprot):
23696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23698 
      return
23699 
    iprot.readStructBegin()
23700 
    while True:
23701 
      (fname, ftype, fid) = iprot.readFieldBegin()
23702 
      if ftype == TType.STOP:
23703 
        break
23704 
      if fid == 1:
23705 
        if ftype == TType.I64:
23706 
          self.status = iprot.readI64();
23707 
        else:
23708 
          iprot.skip(ftype)
23709 
      elif fid == 2:
23710 
        if ftype == TType.I64:
23711 
          self.startDatetime = iprot.readI64();
23712 
        else:
23713 
          iprot.skip(ftype)
23714 
      elif fid == 3:
23715 
        if ftype == TType.I64:
23716 
          self.endDatetime = iprot.readI64();
23717 
        else:
23718 
          iprot.skip(ftype)
23719 
      else:
23720 
        iprot.skip(ftype)
23721 
      iprot.readFieldEnd()
23722 
    iprot.readStructEnd()
23723 
 
23724 
  def write(self, oprot):
23725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23727 
      return
23728 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23729 
    if self.status is not None:
23730 
      oprot.writeFieldBegin('status', TType.I64, 1)
23731 
      oprot.writeI64(self.status)
23732 
      oprot.writeFieldEnd()
23733 
    if self.startDatetime is not None:
23734 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23735 
      oprot.writeI64(self.startDatetime)
23736 
      oprot.writeFieldEnd()
23737 
    if self.endDatetime is not None:
23738 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23739 
      oprot.writeI64(self.endDatetime)
23740 
      oprot.writeFieldEnd()
23741 
    oprot.writeFieldStop()
23742 
    oprot.writeStructEnd()
23743 
 
23744 
  def validate(self):
23745 
    return
23746 
 
23747 
 
23748 
  def __repr__(self):
23749 
    L = ['%s=%r' % (key, value)
23750 
      for key, value in self.__dict__.iteritems()]
23751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23752 
 
23753 
  def __eq__(self, other):
23754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23755 
 
23756 
  def __ne__(self, other):
23757 
    return not (self == other)
23758 
 
23759 
class getOrderIdsForStatus_result:
23760 
  """
23761 
  Attributes:
23762 
   - success
23763 
   - ex
23764 
  """
23765 
 
23766 
  thrift_spec = (
23767 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23768 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23769 
  )
23770 
 
23771 
  def __init__(self, success=None, ex=None,):
23772 
    self.success = success
23773 
    self.ex = ex
23774 
 
23775 
  def read(self, iprot):
23776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23778 
      return
23779 
    iprot.readStructBegin()
23780 
    while True:
23781 
      (fname, ftype, fid) = iprot.readFieldBegin()
23782 
      if ftype == TType.STOP:
23783 
        break
23784 
      if fid == 0:
23785 
        if ftype == TType.LIST:
23786 
          self.success = []
6000 mandeep.dh 23787 
          (_etype567, _size564) = iprot.readListBegin()
23788 
          for _i568 in xrange(_size564):
23789 
            _elem569 = iprot.readI64();
23790 
            self.success.append(_elem569)
5067 varun.gupt 23791 
          iprot.readListEnd()
23792 
        else:
23793 
          iprot.skip(ftype)
23794 
      elif fid == 1:
23795 
        if ftype == TType.STRUCT:
23796 
          self.ex = TransactionServiceException()
23797 
          self.ex.read(iprot)
23798 
        else:
23799 
          iprot.skip(ftype)
23800 
      else:
23801 
        iprot.skip(ftype)
23802 
      iprot.readFieldEnd()
23803 
    iprot.readStructEnd()
23804 
 
23805 
  def write(self, oprot):
23806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23808 
      return
23809 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23810 
    if self.success is not None:
23811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23812 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 23813 
      for iter570 in self.success:
23814 
        oprot.writeI64(iter570)
5067 varun.gupt 23815 
      oprot.writeListEnd()
23816 
      oprot.writeFieldEnd()
23817 
    if self.ex is not None:
23818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23819 
      self.ex.write(oprot)
23820 
      oprot.writeFieldEnd()
23821 
    oprot.writeFieldStop()
23822 
    oprot.writeStructEnd()
23823 
 
23824 
  def validate(self):
23825 
    return
23826 
 
23827 
 
23828 
  def __repr__(self):
23829 
    L = ['%s=%r' % (key, value)
23830 
      for key, value in self.__dict__.iteritems()]
23831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23832 
 
23833 
  def __eq__(self, other):
23834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23835 
 
23836 
  def __ne__(self, other):
23837 
    return not (self == other)
5099 varun.gupt 23838 
 
5348 anupam.sin 23839 
class updateCODAgent_args:
23840 
  """
23841 
  Attributes:
23842 
   - agent
23843 
   - orderId
23844 
  """
23845 
 
23846 
  thrift_spec = (
23847 
    None, # 0
23848 
    (1, TType.STRING, 'agent', None, None, ), # 1
23849 
    (2, TType.I64, 'orderId', None, None, ), # 2
23850 
  )
23851 
 
23852 
  def __init__(self, agent=None, orderId=None,):
23853 
    self.agent = agent
23854 
    self.orderId = orderId
23855 
 
23856 
  def read(self, iprot):
23857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23859 
      return
23860 
    iprot.readStructBegin()
23861 
    while True:
23862 
      (fname, ftype, fid) = iprot.readFieldBegin()
23863 
      if ftype == TType.STOP:
23864 
        break
23865 
      if fid == 1:
23866 
        if ftype == TType.STRING:
23867 
          self.agent = iprot.readString();
23868 
        else:
23869 
          iprot.skip(ftype)
23870 
      elif fid == 2:
23871 
        if ftype == TType.I64:
23872 
          self.orderId = iprot.readI64();
23873 
        else:
23874 
          iprot.skip(ftype)
23875 
      else:
23876 
        iprot.skip(ftype)
23877 
      iprot.readFieldEnd()
23878 
    iprot.readStructEnd()
23879 
 
23880 
  def write(self, oprot):
23881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23883 
      return
23884 
    oprot.writeStructBegin('updateCODAgent_args')
23885 
    if self.agent is not None:
23886 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23887 
      oprot.writeString(self.agent)
23888 
      oprot.writeFieldEnd()
23889 
    if self.orderId is not None:
23890 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23891 
      oprot.writeI64(self.orderId)
23892 
      oprot.writeFieldEnd()
23893 
    oprot.writeFieldStop()
23894 
    oprot.writeStructEnd()
23895 
 
23896 
  def validate(self):
23897 
    return
23898 
 
23899 
 
23900 
  def __repr__(self):
23901 
    L = ['%s=%r' % (key, value)
23902 
      for key, value in self.__dict__.iteritems()]
23903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23904 
 
23905 
  def __eq__(self, other):
23906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23907 
 
23908 
  def __ne__(self, other):
23909 
    return not (self == other)
23910 
 
23911 
class updateCODAgent_result:
23912 
  """
23913 
  Attributes:
23914 
   - ex
23915 
  """
23916 
 
23917 
  thrift_spec = (
23918 
    None, # 0
23919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23920 
  )
23921 
 
23922 
  def __init__(self, ex=None,):
23923 
    self.ex = ex
23924 
 
23925 
  def read(self, iprot):
23926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23928 
      return
23929 
    iprot.readStructBegin()
23930 
    while True:
23931 
      (fname, ftype, fid) = iprot.readFieldBegin()
23932 
      if ftype == TType.STOP:
23933 
        break
23934 
      if fid == 1:
23935 
        if ftype == TType.STRUCT:
23936 
          self.ex = TransactionServiceException()
23937 
          self.ex.read(iprot)
23938 
        else:
23939 
          iprot.skip(ftype)
23940 
      else:
23941 
        iprot.skip(ftype)
23942 
      iprot.readFieldEnd()
23943 
    iprot.readStructEnd()
23944 
 
23945 
  def write(self, oprot):
23946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23948 
      return
23949 
    oprot.writeStructBegin('updateCODAgent_result')
23950 
    if self.ex is not None:
23951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23952 
      self.ex.write(oprot)
23953 
      oprot.writeFieldEnd()
23954 
    oprot.writeFieldStop()
23955 
    oprot.writeStructEnd()
23956 
 
23957 
  def validate(self):
23958 
    return
23959 
 
23960 
 
23961 
  def __repr__(self):
23962 
    L = ['%s=%r' % (key, value)
23963 
      for key, value in self.__dict__.iteritems()]
23964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23965 
 
23966 
  def __eq__(self, other):
23967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23968 
 
23969 
  def __ne__(self, other):
23970 
    return not (self == other)
23971 
 
5099 varun.gupt 23972 
class updateOrderAsPaidToVendor_args:
23973 
  """
23974 
  Attributes:
23975 
   - orderId
23976 
  """
23977 
 
23978 
  thrift_spec = (
23979 
    None, # 0
23980 
    (1, TType.I64, 'orderId', None, None, ), # 1
23981 
  )
23982 
 
23983 
  def __init__(self, orderId=None,):
23984 
    self.orderId = orderId
23985 
 
23986 
  def read(self, iprot):
23987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23989 
      return
23990 
    iprot.readStructBegin()
23991 
    while True:
23992 
      (fname, ftype, fid) = iprot.readFieldBegin()
23993 
      if ftype == TType.STOP:
23994 
        break
23995 
      if fid == 1:
23996 
        if ftype == TType.I64:
23997 
          self.orderId = iprot.readI64();
23998 
        else:
23999 
          iprot.skip(ftype)
24000 
      else:
24001 
        iprot.skip(ftype)
24002 
      iprot.readFieldEnd()
24003 
    iprot.readStructEnd()
24004 
 
24005 
  def write(self, oprot):
24006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24008 
      return
24009 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24010 
    if self.orderId is not None:
24011 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24012 
      oprot.writeI64(self.orderId)
24013 
      oprot.writeFieldEnd()
24014 
    oprot.writeFieldStop()
24015 
    oprot.writeStructEnd()
24016 
 
24017 
  def validate(self):
24018 
    return
24019 
 
24020 
 
24021 
  def __repr__(self):
24022 
    L = ['%s=%r' % (key, value)
24023 
      for key, value in self.__dict__.iteritems()]
24024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24025 
 
24026 
  def __eq__(self, other):
24027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24028 
 
24029 
  def __ne__(self, other):
24030 
    return not (self == other)
24031 
 
24032 
class updateOrderAsPaidToVendor_result:
24033 
  """
24034 
  Attributes:
24035 
   - ex
24036 
  """
24037 
 
24038 
  thrift_spec = (
24039 
    None, # 0
24040 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24041 
  )
24042 
 
24043 
  def __init__(self, ex=None,):
24044 
    self.ex = ex
24045 
 
24046 
  def read(self, iprot):
24047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24049 
      return
24050 
    iprot.readStructBegin()
24051 
    while True:
24052 
      (fname, ftype, fid) = iprot.readFieldBegin()
24053 
      if ftype == TType.STOP:
24054 
        break
24055 
      if fid == 1:
24056 
        if ftype == TType.STRUCT:
24057 
          self.ex = TransactionServiceException()
24058 
          self.ex.read(iprot)
24059 
        else:
24060 
          iprot.skip(ftype)
24061 
      else:
24062 
        iprot.skip(ftype)
24063 
      iprot.readFieldEnd()
24064 
    iprot.readStructEnd()
24065 
 
24066 
  def write(self, oprot):
24067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24069 
      return
24070 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24071 
    if self.ex is not None:
24072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24073 
      self.ex.write(oprot)
24074 
      oprot.writeFieldEnd()
24075 
    oprot.writeFieldStop()
24076 
    oprot.writeStructEnd()
24077 
 
24078 
  def validate(self):
24079 
    return
24080 
 
24081 
 
24082 
  def __repr__(self):
24083 
    L = ['%s=%r' % (key, value)
24084 
      for key, value in self.__dict__.iteritems()]
24085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24086 
 
24087 
  def __eq__(self, other):
24088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24089 
 
24090 
  def __ne__(self, other):
24091 
    return not (self == other)
5208 varun.gupt 24092 
 
5386 phani.kuma 24093 
class updateOrderOnlyAsPaidToVendor_args:
24094 
  """
24095 
  Attributes:
24096 
   - orderId
24097 
  """
24098 
 
24099 
  thrift_spec = (
24100 
    None, # 0
24101 
    (1, TType.I64, 'orderId', None, None, ), # 1
24102 
  )
24103 
 
24104 
  def __init__(self, orderId=None,):
24105 
    self.orderId = orderId
24106 
 
24107 
  def read(self, iprot):
24108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24110 
      return
24111 
    iprot.readStructBegin()
24112 
    while True:
24113 
      (fname, ftype, fid) = iprot.readFieldBegin()
24114 
      if ftype == TType.STOP:
24115 
        break
24116 
      if fid == 1:
24117 
        if ftype == TType.I64:
24118 
          self.orderId = iprot.readI64();
24119 
        else:
24120 
          iprot.skip(ftype)
24121 
      else:
24122 
        iprot.skip(ftype)
24123 
      iprot.readFieldEnd()
24124 
    iprot.readStructEnd()
24125 
 
24126 
  def write(self, oprot):
24127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24129 
      return
24130 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24131 
    if self.orderId is not None:
24132 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24133 
      oprot.writeI64(self.orderId)
24134 
      oprot.writeFieldEnd()
24135 
    oprot.writeFieldStop()
24136 
    oprot.writeStructEnd()
24137 
 
24138 
  def validate(self):
24139 
    return
24140 
 
24141 
 
24142 
  def __repr__(self):
24143 
    L = ['%s=%r' % (key, value)
24144 
      for key, value in self.__dict__.iteritems()]
24145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24146 
 
24147 
  def __eq__(self, other):
24148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24149 
 
24150 
  def __ne__(self, other):
24151 
    return not (self == other)
24152 
 
24153 
class updateOrderOnlyAsPaidToVendor_result:
24154 
  """
24155 
  Attributes:
24156 
   - ex
24157 
  """
24158 
 
24159 
  thrift_spec = (
24160 
    None, # 0
24161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24162 
  )
24163 
 
24164 
  def __init__(self, ex=None,):
24165 
    self.ex = ex
24166 
 
24167 
  def read(self, iprot):
24168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24170 
      return
24171 
    iprot.readStructBegin()
24172 
    while True:
24173 
      (fname, ftype, fid) = iprot.readFieldBegin()
24174 
      if ftype == TType.STOP:
24175 
        break
24176 
      if fid == 1:
24177 
        if ftype == TType.STRUCT:
24178 
          self.ex = TransactionServiceException()
24179 
          self.ex.read(iprot)
24180 
        else:
24181 
          iprot.skip(ftype)
24182 
      else:
24183 
        iprot.skip(ftype)
24184 
      iprot.readFieldEnd()
24185 
    iprot.readStructEnd()
24186 
 
24187 
  def write(self, oprot):
24188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24190 
      return
24191 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24192 
    if self.ex is not None:
24193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24194 
      self.ex.write(oprot)
24195 
      oprot.writeFieldEnd()
24196 
    oprot.writeFieldStop()
24197 
    oprot.writeStructEnd()
24198 
 
24199 
  def validate(self):
24200 
    return
24201 
 
24202 
 
24203 
  def __repr__(self):
24204 
    L = ['%s=%r' % (key, value)
24205 
      for key, value in self.__dict__.iteritems()]
24206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24207 
 
24208 
  def __eq__(self, other):
24209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24210 
 
24211 
  def __ne__(self, other):
24212 
    return not (self == other)
24213 
 
5208 varun.gupt 24214 
class getRefundedOrdersMarkedPaid_args:
24215 
 
24216 
  thrift_spec = (
24217 
  )
24218 
 
24219 
  def read(self, iprot):
24220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24222 
      return
24223 
    iprot.readStructBegin()
24224 
    while True:
24225 
      (fname, ftype, fid) = iprot.readFieldBegin()
24226 
      if ftype == TType.STOP:
24227 
        break
24228 
      else:
24229 
        iprot.skip(ftype)
24230 
      iprot.readFieldEnd()
24231 
    iprot.readStructEnd()
24232 
 
24233 
  def write(self, oprot):
24234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24236 
      return
24237 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24238 
    oprot.writeFieldStop()
24239 
    oprot.writeStructEnd()
24240 
 
24241 
  def validate(self):
24242 
    return
24243 
 
24244 
 
24245 
  def __repr__(self):
24246 
    L = ['%s=%r' % (key, value)
24247 
      for key, value in self.__dict__.iteritems()]
24248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24249 
 
24250 
  def __eq__(self, other):
24251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24252 
 
24253 
  def __ne__(self, other):
24254 
    return not (self == other)
24255 
 
24256 
class getRefundedOrdersMarkedPaid_result:
24257 
  """
24258 
  Attributes:
24259 
   - success
24260 
   - ex
24261 
  """
24262 
 
24263 
  thrift_spec = (
24264 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24266 
  )
24267 
 
24268 
  def __init__(self, success=None, ex=None,):
24269 
    self.success = success
24270 
    self.ex = ex
24271 
 
24272 
  def read(self, iprot):
24273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24275 
      return
24276 
    iprot.readStructBegin()
24277 
    while True:
24278 
      (fname, ftype, fid) = iprot.readFieldBegin()
24279 
      if ftype == TType.STOP:
24280 
        break
24281 
      if fid == 0:
24282 
        if ftype == TType.LIST:
24283 
          self.success = []
6000 mandeep.dh 24284 
          (_etype574, _size571) = iprot.readListBegin()
24285 
          for _i575 in xrange(_size571):
24286 
            _elem576 = Order()
24287 
            _elem576.read(iprot)
24288 
            self.success.append(_elem576)
5208 varun.gupt 24289 
          iprot.readListEnd()
24290 
        else:
24291 
          iprot.skip(ftype)
24292 
      elif fid == 1:
24293 
        if ftype == TType.STRUCT:
24294 
          self.ex = TransactionServiceException()
24295 
          self.ex.read(iprot)
24296 
        else:
24297 
          iprot.skip(ftype)
24298 
      else:
24299 
        iprot.skip(ftype)
24300 
      iprot.readFieldEnd()
24301 
    iprot.readStructEnd()
24302 
 
24303 
  def write(self, oprot):
24304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24306 
      return
24307 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24308 
    if self.success is not None:
24309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24311 
      for iter577 in self.success:
24312 
        iter577.write(oprot)
5208 varun.gupt 24313 
      oprot.writeListEnd()
24314 
      oprot.writeFieldEnd()
24315 
    if self.ex is not None:
24316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24317 
      self.ex.write(oprot)
24318 
      oprot.writeFieldEnd()
24319 
    oprot.writeFieldStop()
24320 
    oprot.writeStructEnd()
24321 
 
24322 
  def validate(self):
24323 
    return
24324 
 
24325 
 
24326 
  def __repr__(self):
24327 
    L = ['%s=%r' % (key, value)
24328 
      for key, value in self.__dict__.iteritems()]
24329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24330 
 
24331 
  def __eq__(self, other):
24332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24333 
 
24334 
  def __ne__(self, other):
24335 
    return not (self == other)
5447 anupam.sin 24336 
 
24337 
class getAllVerificationAgents_args:
24338 
  """
24339 
  Attributes:
24340 
   - minOrderId
24341 
   - maxOrderId
24342 
  """
24343 
 
24344 
  thrift_spec = (
24345 
    None, # 0
24346 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24347 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24348 
  )
24349 
 
24350 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24351 
    self.minOrderId = minOrderId
24352 
    self.maxOrderId = maxOrderId
24353 
 
24354 
  def read(self, iprot):
24355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24357 
      return
24358 
    iprot.readStructBegin()
24359 
    while True:
24360 
      (fname, ftype, fid) = iprot.readFieldBegin()
24361 
      if ftype == TType.STOP:
24362 
        break
24363 
      if fid == 1:
24364 
        if ftype == TType.I64:
24365 
          self.minOrderId = iprot.readI64();
24366 
        else:
24367 
          iprot.skip(ftype)
24368 
      elif fid == 2:
24369 
        if ftype == TType.I64:
24370 
          self.maxOrderId = iprot.readI64();
24371 
        else:
24372 
          iprot.skip(ftype)
24373 
      else:
24374 
        iprot.skip(ftype)
24375 
      iprot.readFieldEnd()
24376 
    iprot.readStructEnd()
24377 
 
24378 
  def write(self, oprot):
24379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24381 
      return
24382 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24383 
    if self.minOrderId is not None:
24384 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24385 
      oprot.writeI64(self.minOrderId)
24386 
      oprot.writeFieldEnd()
24387 
    if self.maxOrderId is not None:
24388 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24389 
      oprot.writeI64(self.maxOrderId)
24390 
      oprot.writeFieldEnd()
24391 
    oprot.writeFieldStop()
24392 
    oprot.writeStructEnd()
24393 
 
24394 
  def validate(self):
24395 
    return
24396 
 
24397 
 
24398 
  def __repr__(self):
24399 
    L = ['%s=%r' % (key, value)
24400 
      for key, value in self.__dict__.iteritems()]
24401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24402 
 
24403 
  def __eq__(self, other):
24404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24405 
 
24406 
  def __ne__(self, other):
24407 
    return not (self == other)
24408 
 
24409 
class getAllVerificationAgents_result:
24410 
  """
24411 
  Attributes:
24412 
   - success
24413 
  """
24414 
 
24415 
  thrift_spec = (
24416 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24417 
  )
24418 
 
24419 
  def __init__(self, success=None,):
24420 
    self.success = success
24421 
 
24422 
  def read(self, iprot):
24423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24425 
      return
24426 
    iprot.readStructBegin()
24427 
    while True:
24428 
      (fname, ftype, fid) = iprot.readFieldBegin()
24429 
      if ftype == TType.STOP:
24430 
        break
24431 
      if fid == 0:
24432 
        if ftype == TType.LIST:
24433 
          self.success = []
6000 mandeep.dh 24434 
          (_etype581, _size578) = iprot.readListBegin()
24435 
          for _i582 in xrange(_size578):
24436 
            _elem583 = CODVerificationAgent()
24437 
            _elem583.read(iprot)
24438 
            self.success.append(_elem583)
5447 anupam.sin 24439 
          iprot.readListEnd()
24440 
        else:
24441 
          iprot.skip(ftype)
24442 
      else:
24443 
        iprot.skip(ftype)
24444 
      iprot.readFieldEnd()
24445 
    iprot.readStructEnd()
24446 
 
24447 
  def write(self, oprot):
24448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24450 
      return
24451 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24452 
    if self.success is not None:
24453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24455 
      for iter584 in self.success:
24456 
        iter584.write(oprot)
5447 anupam.sin 24457 
      oprot.writeListEnd()
24458 
      oprot.writeFieldEnd()
24459 
    oprot.writeFieldStop()
24460 
    oprot.writeStructEnd()
24461 
 
24462 
  def validate(self):
24463 
    return
24464 
 
24465 
 
24466 
  def __repr__(self):
24467 
    L = ['%s=%r' % (key, value)
24468 
      for key, value in self.__dict__.iteritems()]
24469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24470 
 
24471 
  def __eq__(self, other):
24472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24473 
 
24474 
  def __ne__(self, other):
24475 
    return not (self == other)
5527 anupam.sin 24476 
 
24477 
class getAllAttributesForOrderId_args:
24478 
  """
24479 
  Attributes:
24480 
   - orderId
24481 
  """
24482 
 
24483 
  thrift_spec = (
24484 
    None, # 0
24485 
    (1, TType.I64, 'orderId', None, None, ), # 1
24486 
  )
24487 
 
24488 
  def __init__(self, orderId=None,):
24489 
    self.orderId = orderId
24490 
 
24491 
  def read(self, iprot):
24492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24494 
      return
24495 
    iprot.readStructBegin()
24496 
    while True:
24497 
      (fname, ftype, fid) = iprot.readFieldBegin()
24498 
      if ftype == TType.STOP:
24499 
        break
24500 
      if fid == 1:
24501 
        if ftype == TType.I64:
24502 
          self.orderId = iprot.readI64();
24503 
        else:
24504 
          iprot.skip(ftype)
24505 
      else:
24506 
        iprot.skip(ftype)
24507 
      iprot.readFieldEnd()
24508 
    iprot.readStructEnd()
24509 
 
24510 
  def write(self, oprot):
24511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24513 
      return
24514 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24515 
    if self.orderId is not None:
24516 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24517 
      oprot.writeI64(self.orderId)
24518 
      oprot.writeFieldEnd()
24519 
    oprot.writeFieldStop()
24520 
    oprot.writeStructEnd()
24521 
 
24522 
  def validate(self):
24523 
    return
24524 
 
24525 
 
24526 
  def __repr__(self):
24527 
    L = ['%s=%r' % (key, value)
24528 
      for key, value in self.__dict__.iteritems()]
24529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24530 
 
24531 
  def __eq__(self, other):
24532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24533 
 
24534 
  def __ne__(self, other):
24535 
    return not (self == other)
24536 
 
24537 
class getAllAttributesForOrderId_result:
24538 
  """
24539 
  Attributes:
24540 
   - success
24541 
  """
24542 
 
24543 
  thrift_spec = (
24544 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24545 
  )
24546 
 
24547 
  def __init__(self, success=None,):
24548 
    self.success = success
24549 
 
24550 
  def read(self, iprot):
24551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24553 
      return
24554 
    iprot.readStructBegin()
24555 
    while True:
24556 
      (fname, ftype, fid) = iprot.readFieldBegin()
24557 
      if ftype == TType.STOP:
24558 
        break
24559 
      if fid == 0:
24560 
        if ftype == TType.LIST:
24561 
          self.success = []
6000 mandeep.dh 24562 
          (_etype588, _size585) = iprot.readListBegin()
24563 
          for _i589 in xrange(_size585):
24564 
            _elem590 = Attribute()
24565 
            _elem590.read(iprot)
24566 
            self.success.append(_elem590)
5527 anupam.sin 24567 
          iprot.readListEnd()
24568 
        else:
24569 
          iprot.skip(ftype)
24570 
      else:
24571 
        iprot.skip(ftype)
24572 
      iprot.readFieldEnd()
24573 
    iprot.readStructEnd()
24574 
 
24575 
  def write(self, oprot):
24576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24578 
      return
24579 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24580 
    if self.success is not None:
24581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24582 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24583 
      for iter591 in self.success:
24584 
        iter591.write(oprot)
5527 anupam.sin 24585 
      oprot.writeListEnd()
24586 
      oprot.writeFieldEnd()
24587 
    oprot.writeFieldStop()
24588 
    oprot.writeStructEnd()
24589 
 
24590 
  def validate(self):
24591 
    return
24592 
 
24593 
 
24594 
  def __repr__(self):
24595 
    L = ['%s=%r' % (key, value)
24596 
      for key, value in self.__dict__.iteritems()]
24597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24598 
 
24599 
  def __eq__(self, other):
24600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24601 
 
24602 
  def __ne__(self, other):
24603 
    return not (self == other)
24604 
 
5676 rajveer 24605 
class setOrderAttributes_args:
24606 
  """
24607 
  Attributes:
24608 
   - orderId
24609 
   - attributes
24610 
  """
24611 
 
24612 
  thrift_spec = None
24613 
  def __init__(self, orderId=None, attributes=None,):
24614 
    self.orderId = orderId
24615 
    self.attributes = attributes
24616 
 
24617 
  def read(self, iprot):
24618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24620 
      return
24621 
    iprot.readStructBegin()
24622 
    while True:
24623 
      (fname, ftype, fid) = iprot.readFieldBegin()
24624 
      if ftype == TType.STOP:
24625 
        break
24626 
      if fid == 1:
24627 
        if ftype == TType.I64:
24628 
          self.orderId = iprot.readI64();
24629 
        else:
24630 
          iprot.skip(ftype)
24631 
      elif fid == -1:
24632 
        if ftype == TType.LIST:
24633 
          self.attributes = []
6000 mandeep.dh 24634 
          (_etype595, _size592) = iprot.readListBegin()
24635 
          for _i596 in xrange(_size592):
24636 
            _elem597 = Attribute()
24637 
            _elem597.read(iprot)
24638 
            self.attributes.append(_elem597)
5676 rajveer 24639 
          iprot.readListEnd()
24640 
        else:
24641 
          iprot.skip(ftype)
24642 
      else:
24643 
        iprot.skip(ftype)
24644 
      iprot.readFieldEnd()
24645 
    iprot.readStructEnd()
24646 
 
24647 
  def write(self, oprot):
24648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24650 
      return
24651 
    oprot.writeStructBegin('setOrderAttributes_args')
24652 
    if self.attributes is not None:
24653 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24654 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6000 mandeep.dh 24655 
      for iter598 in self.attributes:
24656 
        iter598.write(oprot)
5676 rajveer 24657 
      oprot.writeListEnd()
24658 
      oprot.writeFieldEnd()
24659 
    if self.orderId is not None:
24660 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24661 
      oprot.writeI64(self.orderId)
24662 
      oprot.writeFieldEnd()
24663 
    oprot.writeFieldStop()
24664 
    oprot.writeStructEnd()
24665 
 
24666 
  def validate(self):
24667 
    return
24668 
 
24669 
 
24670 
  def __repr__(self):
24671 
    L = ['%s=%r' % (key, value)
24672 
      for key, value in self.__dict__.iteritems()]
24673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24674 
 
24675 
  def __eq__(self, other):
24676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24677 
 
24678 
  def __ne__(self, other):
24679 
    return not (self == other)
24680 
 
24681 
class setOrderAttributes_result:
24682 
 
24683 
  thrift_spec = (
24684 
  )
24685 
 
24686 
  def read(self, iprot):
24687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24689 
      return
24690 
    iprot.readStructBegin()
24691 
    while True:
24692 
      (fname, ftype, fid) = iprot.readFieldBegin()
24693 
      if ftype == TType.STOP:
24694 
        break
24695 
      else:
24696 
        iprot.skip(ftype)
24697 
      iprot.readFieldEnd()
24698 
    iprot.readStructEnd()
24699 
 
24700 
  def write(self, oprot):
24701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24703 
      return
24704 
    oprot.writeStructBegin('setOrderAttributes_result')
24705 
    oprot.writeFieldStop()
24706 
    oprot.writeStructEnd()
24707 
 
24708 
  def validate(self):
24709 
    return
24710 
 
24711 
 
24712 
  def __repr__(self):
24713 
    L = ['%s=%r' % (key, value)
24714 
      for key, value in self.__dict__.iteritems()]
24715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24716 
 
24717 
  def __eq__(self, other):
24718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24719 
 
24720 
  def __ne__(self, other):
24721 
    return not (self == other)
24722 
 
5527 anupam.sin 24723 
class setOrderAttributeForTransaction_args:
24724 
  """
24725 
  Attributes:
24726 
   - transactionId
24727 
   - attribute
24728 
  """
24729 
 
24730 
  thrift_spec = None
24731 
  def __init__(self, transactionId=None, attribute=None,):
24732 
    self.transactionId = transactionId
24733 
    self.attribute = attribute
24734 
 
24735 
  def read(self, iprot):
24736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24738 
      return
24739 
    iprot.readStructBegin()
24740 
    while True:
24741 
      (fname, ftype, fid) = iprot.readFieldBegin()
24742 
      if ftype == TType.STOP:
24743 
        break
24744 
      if fid == 1:
24745 
        if ftype == TType.I64:
24746 
          self.transactionId = iprot.readI64();
24747 
        else:
24748 
          iprot.skip(ftype)
24749 
      elif fid == -1:
24750 
        if ftype == TType.STRUCT:
24751 
          self.attribute = Attribute()
24752 
          self.attribute.read(iprot)
24753 
        else:
24754 
          iprot.skip(ftype)
24755 
      else:
24756 
        iprot.skip(ftype)
24757 
      iprot.readFieldEnd()
24758 
    iprot.readStructEnd()
24759 
 
24760 
  def write(self, oprot):
24761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24763 
      return
24764 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24765 
    if self.attribute is not None:
24766 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24767 
      self.attribute.write(oprot)
24768 
      oprot.writeFieldEnd()
24769 
    if self.transactionId is not None:
24770 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24771 
      oprot.writeI64(self.transactionId)
24772 
      oprot.writeFieldEnd()
24773 
    oprot.writeFieldStop()
24774 
    oprot.writeStructEnd()
24775 
 
24776 
  def validate(self):
24777 
    return
24778 
 
24779 
 
24780 
  def __repr__(self):
24781 
    L = ['%s=%r' % (key, value)
24782 
      for key, value in self.__dict__.iteritems()]
24783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24784 
 
24785 
  def __eq__(self, other):
24786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24787 
 
24788 
  def __ne__(self, other):
24789 
    return not (self == other)
24790 
 
24791 
class setOrderAttributeForTransaction_result:
24792 
 
24793 
  thrift_spec = (
24794 
  )
24795 
 
24796 
  def read(self, iprot):
24797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24799 
      return
24800 
    iprot.readStructBegin()
24801 
    while True:
24802 
      (fname, ftype, fid) = iprot.readFieldBegin()
24803 
      if ftype == TType.STOP:
24804 
        break
24805 
      else:
24806 
        iprot.skip(ftype)
24807 
      iprot.readFieldEnd()
24808 
    iprot.readStructEnd()
24809 
 
24810 
  def write(self, oprot):
24811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24813 
      return
24814 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24815 
    oprot.writeFieldStop()
24816 
    oprot.writeStructEnd()
24817 
 
24818 
  def validate(self):
24819 
    return
24820 
 
24821 
 
24822 
  def __repr__(self):
24823 
    L = ['%s=%r' % (key, value)
24824 
      for key, value in self.__dict__.iteritems()]
24825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24826 
 
24827 
  def __eq__(self, other):
24828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24829 
 
24830 
  def __ne__(self, other):
24831 
    return not (self == other)
5553 rajveer 24832 
 
24833 
class getReceivePendingOrders_args:
24834 
  """
24835 
  Attributes:
24836 
   - storeId
24837 
  """
24838 
 
24839 
  thrift_spec = (
24840 
    None, # 0
24841 
    (1, TType.I64, 'storeId', None, None, ), # 1
24842 
  )
24843 
 
24844 
  def __init__(self, storeId=None,):
24845 
    self.storeId = storeId
24846 
 
24847 
  def read(self, iprot):
24848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24850 
      return
24851 
    iprot.readStructBegin()
24852 
    while True:
24853 
      (fname, ftype, fid) = iprot.readFieldBegin()
24854 
      if ftype == TType.STOP:
24855 
        break
24856 
      if fid == 1:
24857 
        if ftype == TType.I64:
24858 
          self.storeId = iprot.readI64();
24859 
        else:
24860 
          iprot.skip(ftype)
24861 
      else:
24862 
        iprot.skip(ftype)
24863 
      iprot.readFieldEnd()
24864 
    iprot.readStructEnd()
24865 
 
24866 
  def write(self, oprot):
24867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24869 
      return
24870 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24871 
    if self.storeId is not None:
24872 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24873 
      oprot.writeI64(self.storeId)
24874 
      oprot.writeFieldEnd()
24875 
    oprot.writeFieldStop()
24876 
    oprot.writeStructEnd()
24877 
 
24878 
  def validate(self):
24879 
    return
24880 
 
24881 
 
24882 
  def __repr__(self):
24883 
    L = ['%s=%r' % (key, value)
24884 
      for key, value in self.__dict__.iteritems()]
24885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24886 
 
24887 
  def __eq__(self, other):
24888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24889 
 
24890 
  def __ne__(self, other):
24891 
    return not (self == other)
24892 
 
24893 
class getReceivePendingOrders_result:
24894 
  """
24895 
  Attributes:
24896 
   - success
24897 
  """
24898 
 
24899 
  thrift_spec = (
24900 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24901 
  )
24902 
 
24903 
  def __init__(self, success=None,):
24904 
    self.success = success
24905 
 
24906 
  def read(self, iprot):
24907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24909 
      return
24910 
    iprot.readStructBegin()
24911 
    while True:
24912 
      (fname, ftype, fid) = iprot.readFieldBegin()
24913 
      if ftype == TType.STOP:
24914 
        break
24915 
      if fid == 0:
24916 
        if ftype == TType.LIST:
24917 
          self.success = []
6000 mandeep.dh 24918 
          (_etype602, _size599) = iprot.readListBegin()
24919 
          for _i603 in xrange(_size599):
24920 
            _elem604 = Order()
24921 
            _elem604.read(iprot)
24922 
            self.success.append(_elem604)
5553 rajveer 24923 
          iprot.readListEnd()
24924 
        else:
24925 
          iprot.skip(ftype)
24926 
      else:
24927 
        iprot.skip(ftype)
24928 
      iprot.readFieldEnd()
24929 
    iprot.readStructEnd()
24930 
 
24931 
  def write(self, oprot):
24932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24934 
      return
24935 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24936 
    if self.success is not None:
24937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24939 
      for iter605 in self.success:
24940 
        iter605.write(oprot)
5553 rajveer 24941 
      oprot.writeListEnd()
24942 
      oprot.writeFieldEnd()
24943 
    oprot.writeFieldStop()
24944 
    oprot.writeStructEnd()
24945 
 
24946 
  def validate(self):
24947 
    return
24948 
 
24949 
 
24950 
  def __repr__(self):
24951 
    L = ['%s=%r' % (key, value)
24952 
      for key, value in self.__dict__.iteritems()]
24953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24954 
 
24955 
  def __eq__(self, other):
24956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24957 
 
24958 
  def __ne__(self, other):
24959 
    return not (self == other)
24960 
 
24961 
class getReceivedAtStoreOrders_args:
24962 
  """
24963 
  Attributes:
24964 
   - storeId
24965 
  """
24966 
 
24967 
  thrift_spec = (
24968 
    None, # 0
24969 
    (1, TType.I64, 'storeId', None, None, ), # 1
24970 
  )
24971 
 
24972 
  def __init__(self, storeId=None,):
24973 
    self.storeId = storeId
24974 
 
24975 
  def read(self, iprot):
24976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24978 
      return
24979 
    iprot.readStructBegin()
24980 
    while True:
24981 
      (fname, ftype, fid) = iprot.readFieldBegin()
24982 
      if ftype == TType.STOP:
24983 
        break
24984 
      if fid == 1:
24985 
        if ftype == TType.I64:
24986 
          self.storeId = iprot.readI64();
24987 
        else:
24988 
          iprot.skip(ftype)
24989 
      else:
24990 
        iprot.skip(ftype)
24991 
      iprot.readFieldEnd()
24992 
    iprot.readStructEnd()
24993 
 
24994 
  def write(self, oprot):
24995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24997 
      return
24998 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24999 
    if self.storeId is not None:
25000 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25001 
      oprot.writeI64(self.storeId)
25002 
      oprot.writeFieldEnd()
25003 
    oprot.writeFieldStop()
25004 
    oprot.writeStructEnd()
25005 
 
25006 
  def validate(self):
25007 
    return
25008 
 
25009 
 
25010 
  def __repr__(self):
25011 
    L = ['%s=%r' % (key, value)
25012 
      for key, value in self.__dict__.iteritems()]
25013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25014 
 
25015 
  def __eq__(self, other):
25016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25017 
 
25018 
  def __ne__(self, other):
25019 
    return not (self == other)
25020 
 
25021 
class getReceivedAtStoreOrders_result:
25022 
  """
25023 
  Attributes:
25024 
   - success
25025 
  """
25026 
 
25027 
  thrift_spec = (
25028 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25029 
  )
25030 
 
25031 
  def __init__(self, success=None,):
25032 
    self.success = success
25033 
 
25034 
  def read(self, iprot):
25035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25037 
      return
25038 
    iprot.readStructBegin()
25039 
    while True:
25040 
      (fname, ftype, fid) = iprot.readFieldBegin()
25041 
      if ftype == TType.STOP:
25042 
        break
25043 
      if fid == 0:
25044 
        if ftype == TType.LIST:
25045 
          self.success = []
6000 mandeep.dh 25046 
          (_etype609, _size606) = iprot.readListBegin()
25047 
          for _i610 in xrange(_size606):
25048 
            _elem611 = Order()
25049 
            _elem611.read(iprot)
25050 
            self.success.append(_elem611)
5553 rajveer 25051 
          iprot.readListEnd()
25052 
        else:
25053 
          iprot.skip(ftype)
25054 
      else:
25055 
        iprot.skip(ftype)
25056 
      iprot.readFieldEnd()
25057 
    iprot.readStructEnd()
25058 
 
25059 
  def write(self, oprot):
25060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25062 
      return
25063 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25064 
    if self.success is not None:
25065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 25067 
      for iter612 in self.success:
25068 
        iter612.write(oprot)
5553 rajveer 25069 
      oprot.writeListEnd()
25070 
      oprot.writeFieldEnd()
25071 
    oprot.writeFieldStop()
25072 
    oprot.writeStructEnd()
25073 
 
25074 
  def validate(self):
25075 
    return
25076 
 
25077 
 
25078 
  def __repr__(self):
25079 
    L = ['%s=%r' % (key, value)
25080 
      for key, value in self.__dict__.iteritems()]
25081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25082 
 
25083 
  def __eq__(self, other):
25084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25085 
 
25086 
  def __ne__(self, other):
25087 
    return not (self == other)
5593 mandeep.dh 25088 
 
5713 rajveer 25089 
class getOrdersCollectionAtStore_args:
25090 
  """
25091 
  Attributes:
25092 
   - storeId
25093 
   - fromDate
25094 
   - toDate
25095 
   - onlyCod
25096 
  """
25097 
 
25098 
  thrift_spec = (
25099 
    None, # 0
25100 
    (1, TType.I64, 'storeId', None, None, ), # 1
25101 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25102 
    (3, TType.I64, 'toDate', None, None, ), # 3
25103 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25104 
  )
25105 
 
25106 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25107 
    self.storeId = storeId
25108 
    self.fromDate = fromDate
25109 
    self.toDate = toDate
25110 
    self.onlyCod = onlyCod
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 1:
25122 
        if ftype == TType.I64:
25123 
          self.storeId = iprot.readI64();
25124 
        else:
25125 
          iprot.skip(ftype)
25126 
      elif fid == 2:
25127 
        if ftype == TType.I64:
25128 
          self.fromDate = iprot.readI64();
25129 
        else:
25130 
          iprot.skip(ftype)
25131 
      elif fid == 3:
25132 
        if ftype == TType.I64:
25133 
          self.toDate = iprot.readI64();
25134 
        else:
25135 
          iprot.skip(ftype)
25136 
      elif fid == 4:
25137 
        if ftype == TType.BOOL:
25138 
          self.onlyCod = iprot.readBool();
25139 
        else:
25140 
          iprot.skip(ftype)
25141 
      else:
25142 
        iprot.skip(ftype)
25143 
      iprot.readFieldEnd()
25144 
    iprot.readStructEnd()
25145 
 
25146 
  def write(self, oprot):
25147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25149 
      return
25150 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25151 
    if self.storeId is not None:
25152 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25153 
      oprot.writeI64(self.storeId)
25154 
      oprot.writeFieldEnd()
25155 
    if self.fromDate is not None:
25156 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25157 
      oprot.writeI64(self.fromDate)
25158 
      oprot.writeFieldEnd()
25159 
    if self.toDate is not None:
25160 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25161 
      oprot.writeI64(self.toDate)
25162 
      oprot.writeFieldEnd()
25163 
    if self.onlyCod is not None:
25164 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25165 
      oprot.writeBool(self.onlyCod)
25166 
      oprot.writeFieldEnd()
25167 
    oprot.writeFieldStop()
25168 
    oprot.writeStructEnd()
25169 
 
25170 
  def validate(self):
25171 
    return
25172 
 
25173 
 
25174 
  def __repr__(self):
25175 
    L = ['%s=%r' % (key, value)
25176 
      for key, value in self.__dict__.iteritems()]
25177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25178 
 
25179 
  def __eq__(self, other):
25180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25181 
 
25182 
  def __ne__(self, other):
25183 
    return not (self == other)
25184 
 
25185 
class getOrdersCollectionAtStore_result:
25186 
  """
25187 
  Attributes:
25188 
   - success
25189 
  """
25190 
 
25191 
  thrift_spec = (
25192 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25193 
  )
25194 
 
25195 
  def __init__(self, success=None,):
25196 
    self.success = success
25197 
 
25198 
  def read(self, iprot):
25199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25201 
      return
25202 
    iprot.readStructBegin()
25203 
    while True:
25204 
      (fname, ftype, fid) = iprot.readFieldBegin()
25205 
      if ftype == TType.STOP:
25206 
        break
25207 
      if fid == 0:
25208 
        if ftype == TType.LIST:
25209 
          self.success = []
6000 mandeep.dh 25210 
          (_etype616, _size613) = iprot.readListBegin()
25211 
          for _i617 in xrange(_size613):
25212 
            _elem618 = Order()
25213 
            _elem618.read(iprot)
25214 
            self.success.append(_elem618)
5713 rajveer 25215 
          iprot.readListEnd()
25216 
        else:
25217 
          iprot.skip(ftype)
25218 
      else:
25219 
        iprot.skip(ftype)
25220 
      iprot.readFieldEnd()
25221 
    iprot.readStructEnd()
25222 
 
25223 
  def write(self, oprot):
25224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25226 
      return
25227 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25228 
    if self.success is not None:
25229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 25231 
      for iter619 in self.success:
25232 
        iter619.write(oprot)
5713 rajveer 25233 
      oprot.writeListEnd()
25234 
      oprot.writeFieldEnd()
25235 
    oprot.writeFieldStop()
25236 
    oprot.writeStructEnd()
25237 
 
25238 
  def validate(self):
25239 
    return
25240 
 
25241 
 
25242 
  def __repr__(self):
25243 
    L = ['%s=%r' % (key, value)
25244 
      for key, value in self.__dict__.iteritems()]
25245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25246 
 
25247 
  def __eq__(self, other):
25248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25249 
 
25250 
  def __ne__(self, other):
25251 
    return not (self == other)
25252 
 
5833 rajveer 25253 
class getOrderAttributeValue_args:
25254 
  """
25255 
  Attributes:
25256 
   - orderId
25257 
   - attributeName
25258 
  """
25259 
 
25260 
  thrift_spec = None
25261 
  def __init__(self, orderId=None, attributeName=None,):
25262 
    self.orderId = orderId
25263 
    self.attributeName = attributeName
25264 
 
25265 
  def read(self, iprot):
25266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25268 
      return
25269 
    iprot.readStructBegin()
25270 
    while True:
25271 
      (fname, ftype, fid) = iprot.readFieldBegin()
25272 
      if ftype == TType.STOP:
25273 
        break
25274 
      if fid == 1:
25275 
        if ftype == TType.I64:
25276 
          self.orderId = iprot.readI64();
25277 
        else:
25278 
          iprot.skip(ftype)
25279 
      elif fid == -1:
25280 
        if ftype == TType.STRING:
25281 
          self.attributeName = iprot.readString();
25282 
        else:
25283 
          iprot.skip(ftype)
25284 
      else:
25285 
        iprot.skip(ftype)
25286 
      iprot.readFieldEnd()
25287 
    iprot.readStructEnd()
25288 
 
25289 
  def write(self, oprot):
25290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25292 
      return
25293 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25294 
    if self.attributeName is not None:
25295 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25296 
      oprot.writeString(self.attributeName)
25297 
      oprot.writeFieldEnd()
25298 
    if self.orderId is not None:
25299 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25300 
      oprot.writeI64(self.orderId)
25301 
      oprot.writeFieldEnd()
25302 
    oprot.writeFieldStop()
25303 
    oprot.writeStructEnd()
25304 
 
25305 
  def validate(self):
25306 
    return
25307 
 
25308 
 
25309 
  def __repr__(self):
25310 
    L = ['%s=%r' % (key, value)
25311 
      for key, value in self.__dict__.iteritems()]
25312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25313 
 
25314 
  def __eq__(self, other):
25315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25316 
 
25317 
  def __ne__(self, other):
25318 
    return not (self == other)
25319 
 
25320 
class getOrderAttributeValue_result:
25321 
  """
25322 
  Attributes:
25323 
   - success
25324 
  """
25325 
 
25326 
  thrift_spec = (
25327 
    (0, TType.STRING, 'success', None, None, ), # 0
25328 
  )
25329 
 
25330 
  def __init__(self, success=None,):
25331 
    self.success = success
25332 
 
25333 
  def read(self, iprot):
25334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25336 
      return
25337 
    iprot.readStructBegin()
25338 
    while True:
25339 
      (fname, ftype, fid) = iprot.readFieldBegin()
25340 
      if ftype == TType.STOP:
25341 
        break
25342 
      if fid == 0:
25343 
        if ftype == TType.STRING:
25344 
          self.success = iprot.readString();
25345 
        else:
25346 
          iprot.skip(ftype)
25347 
      else:
25348 
        iprot.skip(ftype)
25349 
      iprot.readFieldEnd()
25350 
    iprot.readStructEnd()
25351 
 
25352 
  def write(self, oprot):
25353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25355 
      return
25356 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25357 
    if self.success is not None:
25358 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25359 
      oprot.writeString(self.success)
25360 
      oprot.writeFieldEnd()
25361 
    oprot.writeFieldStop()
25362 
    oprot.writeStructEnd()
25363 
 
25364 
  def validate(self):
25365 
    return
25366 
 
25367 
 
25368 
  def __repr__(self):
25369 
    L = ['%s=%r' % (key, value)
25370 
      for key, value in self.__dict__.iteritems()]
25371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25372 
 
25373 
  def __eq__(self, other):
25374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25375 
 
25376 
  def __ne__(self, other):
25377 
    return not (self == other)
25378 
 
5593 mandeep.dh 25379 
class acceptOrderForItem_args:
25380 
  """
25381 
  Attributes:
25382 
   - itemId
25383 
   - quantity
25384 
   - fulfilmentWarehouseId
25385 
   - billingWarehouseId
25386 
  """
25387 
 
25388 
  thrift_spec = (
25389 
    None, # 0
25390 
    (1, TType.I64, 'itemId', None, None, ), # 1
25391 
    (2, TType.I64, 'quantity', None, None, ), # 2
25392 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25393 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25394 
  )
25395 
 
25396 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25397 
    self.itemId = itemId
25398 
    self.quantity = quantity
25399 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25400 
    self.billingWarehouseId = billingWarehouseId
25401 
 
25402 
  def read(self, iprot):
25403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25405 
      return
25406 
    iprot.readStructBegin()
25407 
    while True:
25408 
      (fname, ftype, fid) = iprot.readFieldBegin()
25409 
      if ftype == TType.STOP:
25410 
        break
25411 
      if fid == 1:
25412 
        if ftype == TType.I64:
25413 
          self.itemId = iprot.readI64();
25414 
        else:
25415 
          iprot.skip(ftype)
25416 
      elif fid == 2:
25417 
        if ftype == TType.I64:
25418 
          self.quantity = iprot.readI64();
25419 
        else:
25420 
          iprot.skip(ftype)
25421 
      elif fid == 3:
25422 
        if ftype == TType.I64:
25423 
          self.fulfilmentWarehouseId = iprot.readI64();
25424 
        else:
25425 
          iprot.skip(ftype)
25426 
      elif fid == 4:
25427 
        if ftype == TType.I64:
25428 
          self.billingWarehouseId = iprot.readI64();
25429 
        else:
25430 
          iprot.skip(ftype)
25431 
      else:
25432 
        iprot.skip(ftype)
25433 
      iprot.readFieldEnd()
25434 
    iprot.readStructEnd()
25435 
 
25436 
  def write(self, oprot):
25437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25439 
      return
25440 
    oprot.writeStructBegin('acceptOrderForItem_args')
25441 
    if self.itemId is not None:
25442 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25443 
      oprot.writeI64(self.itemId)
25444 
      oprot.writeFieldEnd()
25445 
    if self.quantity is not None:
25446 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25447 
      oprot.writeI64(self.quantity)
25448 
      oprot.writeFieldEnd()
25449 
    if self.fulfilmentWarehouseId is not None:
25450 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
25451 
      oprot.writeI64(self.fulfilmentWarehouseId)
25452 
      oprot.writeFieldEnd()
25453 
    if self.billingWarehouseId is not None:
25454 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
25455 
      oprot.writeI64(self.billingWarehouseId)
25456 
      oprot.writeFieldEnd()
25457 
    oprot.writeFieldStop()
25458 
    oprot.writeStructEnd()
25459 
 
25460 
  def validate(self):
25461 
    return
25462 
 
25463 
 
25464 
  def __repr__(self):
25465 
    L = ['%s=%r' % (key, value)
25466 
      for key, value in self.__dict__.iteritems()]
25467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25468 
 
25469 
  def __eq__(self, other):
25470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25471 
 
25472 
  def __ne__(self, other):
25473 
    return not (self == other)
25474 
 
25475 
class acceptOrderForItem_result:
25476 
 
25477 
  thrift_spec = (
25478 
  )
25479 
 
25480 
  def read(self, iprot):
25481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25483 
      return
25484 
    iprot.readStructBegin()
25485 
    while True:
25486 
      (fname, ftype, fid) = iprot.readFieldBegin()
25487 
      if ftype == TType.STOP:
25488 
        break
25489 
      else:
25490 
        iprot.skip(ftype)
25491 
      iprot.readFieldEnd()
25492 
    iprot.readStructEnd()
25493 
 
25494 
  def write(self, oprot):
25495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25497 
      return
25498 
    oprot.writeStructBegin('acceptOrderForItem_result')
25499 
    oprot.writeFieldStop()
25500 
    oprot.writeStructEnd()
25501 
 
25502 
  def validate(self):
25503 
    return
25504 
 
25505 
 
25506 
  def __repr__(self):
25507 
    L = ['%s=%r' % (key, value)
25508 
      for key, value in self.__dict__.iteritems()]
25509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25510 
 
25511 
  def __eq__(self, other):
25512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25513 
 
25514 
  def __ne__(self, other):
25515 
    return not (self == other)
6000 mandeep.dh 25516 
 
25517 
class createRechargeOrder_args:
25518 
  """
25519 
  Attributes:
25520 
   - rechargeOrder
25521 
  """
25522 
 
25523 
  thrift_spec = (
25524 
    None, # 0
25525 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
25526 
  )
25527 
 
25528 
  def __init__(self, rechargeOrder=None,):
25529 
    self.rechargeOrder = rechargeOrder
25530 
 
25531 
  def read(self, iprot):
25532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25534 
      return
25535 
    iprot.readStructBegin()
25536 
    while True:
25537 
      (fname, ftype, fid) = iprot.readFieldBegin()
25538 
      if ftype == TType.STOP:
25539 
        break
25540 
      if fid == 1:
25541 
        if ftype == TType.STRUCT:
25542 
          self.rechargeOrder = RechargeOrder()
25543 
          self.rechargeOrder.read(iprot)
25544 
        else:
25545 
          iprot.skip(ftype)
25546 
      else:
25547 
        iprot.skip(ftype)
25548 
      iprot.readFieldEnd()
25549 
    iprot.readStructEnd()
25550 
 
25551 
  def write(self, oprot):
25552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25554 
      return
25555 
    oprot.writeStructBegin('createRechargeOrder_args')
25556 
    if self.rechargeOrder is not None:
25557 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
25558 
      self.rechargeOrder.write(oprot)
25559 
      oprot.writeFieldEnd()
25560 
    oprot.writeFieldStop()
25561 
    oprot.writeStructEnd()
25562 
 
25563 
  def validate(self):
25564 
    return
25565 
 
25566 
 
25567 
  def __repr__(self):
25568 
    L = ['%s=%r' % (key, value)
25569 
      for key, value in self.__dict__.iteritems()]
25570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25571 
 
25572 
  def __eq__(self, other):
25573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25574 
 
25575 
  def __ne__(self, other):
25576 
    return not (self == other)
25577 
 
25578 
class createRechargeOrder_result:
25579 
  """
25580 
  Attributes:
25581 
   - success
25582 
   - ex
25583 
  """
25584 
 
25585 
  thrift_spec = (
25586 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
25587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25588 
  )
25589 
 
25590 
  def __init__(self, success=None, ex=None,):
25591 
    self.success = success
25592 
    self.ex = ex
25593 
 
25594 
  def read(self, iprot):
25595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25597 
      return
25598 
    iprot.readStructBegin()
25599 
    while True:
25600 
      (fname, ftype, fid) = iprot.readFieldBegin()
25601 
      if ftype == TType.STOP:
25602 
        break
25603 
      if fid == 0:
25604 
        if ftype == TType.STRUCT:
25605 
          self.success = RechargeOrder()
25606 
          self.success.read(iprot)
25607 
        else:
25608 
          iprot.skip(ftype)
25609 
      elif fid == 1:
25610 
        if ftype == TType.STRUCT:
25611 
          self.ex = TransactionServiceException()
25612 
          self.ex.read(iprot)
25613 
        else:
25614 
          iprot.skip(ftype)
25615 
      else:
25616 
        iprot.skip(ftype)
25617 
      iprot.readFieldEnd()
25618 
    iprot.readStructEnd()
25619 
 
25620 
  def write(self, oprot):
25621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25623 
      return
25624 
    oprot.writeStructBegin('createRechargeOrder_result')
25625 
    if self.success is not None:
25626 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25627 
      self.success.write(oprot)
25628 
      oprot.writeFieldEnd()
25629 
    if self.ex is not None:
25630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25631 
      self.ex.write(oprot)
25632 
      oprot.writeFieldEnd()
25633 
    oprot.writeFieldStop()
25634 
    oprot.writeStructEnd()
25635 
 
25636 
  def validate(self):
25637 
    return
25638 
 
25639 
 
25640 
  def __repr__(self):
25641 
    L = ['%s=%r' % (key, value)
25642 
      for key, value in self.__dict__.iteritems()]
25643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25644 
 
25645 
  def __eq__(self, other):
25646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25647 
 
25648 
  def __ne__(self, other):
25649 
    return not (self == other)
25650 
 
25651 
class updateRechargeOrderStatus_args:
25652 
  """
25653 
  Attributes:
25654 
   - rechargeOrderId
25655 
   - rechargeOrderStatus
25656 
  """
25657 
 
25658 
  thrift_spec = (
25659 
    None, # 0
25660 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
25661 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
25662 
  )
25663 
 
25664 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
25665 
    self.rechargeOrderId = rechargeOrderId
25666 
    self.rechargeOrderStatus = rechargeOrderStatus
25667 
 
25668 
  def read(self, iprot):
25669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25671 
      return
25672 
    iprot.readStructBegin()
25673 
    while True:
25674 
      (fname, ftype, fid) = iprot.readFieldBegin()
25675 
      if ftype == TType.STOP:
25676 
        break
25677 
      if fid == 1:
25678 
        if ftype == TType.I64:
25679 
          self.rechargeOrderId = iprot.readI64();
25680 
        else:
25681 
          iprot.skip(ftype)
25682 
      elif fid == 2:
25683 
        if ftype == TType.I32:
25684 
          self.rechargeOrderStatus = iprot.readI32();
25685 
        else:
25686 
          iprot.skip(ftype)
25687 
      else:
25688 
        iprot.skip(ftype)
25689 
      iprot.readFieldEnd()
25690 
    iprot.readStructEnd()
25691 
 
25692 
  def write(self, oprot):
25693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25695 
      return
25696 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
25697 
    if self.rechargeOrderId is not None:
25698 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
25699 
      oprot.writeI64(self.rechargeOrderId)
25700 
      oprot.writeFieldEnd()
25701 
    if self.rechargeOrderStatus is not None:
25702 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
25703 
      oprot.writeI32(self.rechargeOrderStatus)
25704 
      oprot.writeFieldEnd()
25705 
    oprot.writeFieldStop()
25706 
    oprot.writeStructEnd()
25707 
 
25708 
  def validate(self):
25709 
    return
25710 
 
25711 
 
25712 
  def __repr__(self):
25713 
    L = ['%s=%r' % (key, value)
25714 
      for key, value in self.__dict__.iteritems()]
25715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25716 
 
25717 
  def __eq__(self, other):
25718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25719 
 
25720 
  def __ne__(self, other):
25721 
    return not (self == other)
25722 
 
25723 
class updateRechargeOrderStatus_result:
25724 
  """
25725 
  Attributes:
25726 
   - ex
25727 
  """
25728 
 
25729 
  thrift_spec = (
25730 
    None, # 0
25731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25732 
  )
25733 
 
25734 
  def __init__(self, ex=None,):
25735 
    self.ex = ex
25736 
 
25737 
  def read(self, iprot):
25738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25740 
      return
25741 
    iprot.readStructBegin()
25742 
    while True:
25743 
      (fname, ftype, fid) = iprot.readFieldBegin()
25744 
      if ftype == TType.STOP:
25745 
        break
25746 
      if fid == 1:
25747 
        if ftype == TType.STRUCT:
25748 
          self.ex = TransactionServiceException()
25749 
          self.ex.read(iprot)
25750 
        else:
25751 
          iprot.skip(ftype)
25752 
      else:
25753 
        iprot.skip(ftype)
25754 
      iprot.readFieldEnd()
25755 
    iprot.readStructEnd()
25756 
 
25757 
  def write(self, oprot):
25758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25760 
      return
25761 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
25762 
    if self.ex is not None:
25763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25764 
      self.ex.write(oprot)
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 activateRechargeTxn_args:
25785 
  """
25786 
  Attributes:
25787 
   - rechargeCoupons
25788 
  """
25789 
 
25790 
  thrift_spec = (
25791 
    None, # 0
25792 
    (1, TType.LIST, 'rechargeCoupons', (TType.STRUCT,(RechargeCoupon, RechargeCoupon.thrift_spec)), None, ), # 1
25793 
  )
25794 
 
25795 
  def __init__(self, rechargeCoupons=None,):
25796 
    self.rechargeCoupons = rechargeCoupons
25797 
 
25798 
  def read(self, iprot):
25799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25801 
      return
25802 
    iprot.readStructBegin()
25803 
    while True:
25804 
      (fname, ftype, fid) = iprot.readFieldBegin()
25805 
      if ftype == TType.STOP:
25806 
        break
25807 
      if fid == 1:
25808 
        if ftype == TType.LIST:
25809 
          self.rechargeCoupons = []
25810 
          (_etype623, _size620) = iprot.readListBegin()
25811 
          for _i624 in xrange(_size620):
25812 
            _elem625 = RechargeCoupon()
25813 
            _elem625.read(iprot)
25814 
            self.rechargeCoupons.append(_elem625)
25815 
          iprot.readListEnd()
25816 
        else:
25817 
          iprot.skip(ftype)
25818 
      else:
25819 
        iprot.skip(ftype)
25820 
      iprot.readFieldEnd()
25821 
    iprot.readStructEnd()
25822 
 
25823 
  def write(self, oprot):
25824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25826 
      return
25827 
    oprot.writeStructBegin('activateRechargeTxn_args')
25828 
    if self.rechargeCoupons is not None:
25829 
      oprot.writeFieldBegin('rechargeCoupons', TType.LIST, 1)
25830 
      oprot.writeListBegin(TType.STRUCT, len(self.rechargeCoupons))
25831 
      for iter626 in self.rechargeCoupons:
25832 
        iter626.write(oprot)
25833 
      oprot.writeListEnd()
25834 
      oprot.writeFieldEnd()
25835 
    oprot.writeFieldStop()
25836 
    oprot.writeStructEnd()
25837 
 
25838 
  def validate(self):
25839 
    return
25840 
 
25841 
 
25842 
  def __repr__(self):
25843 
    L = ['%s=%r' % (key, value)
25844 
      for key, value in self.__dict__.iteritems()]
25845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25846 
 
25847 
  def __eq__(self, other):
25848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25849 
 
25850 
  def __ne__(self, other):
25851 
    return not (self == other)
25852 
 
25853 
class activateRechargeTxn_result:
25854 
  """
25855 
  Attributes:
25856 
   - success
25857 
   - ex
25858 
  """
25859 
 
25860 
  thrift_spec = (
25861 
    (0, TType.STRUCT, 'success', (RechargeResponse, RechargeResponse.thrift_spec), None, ), # 0
25862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25863 
  )
25864 
 
25865 
  def __init__(self, success=None, ex=None,):
25866 
    self.success = success
25867 
    self.ex = ex
25868 
 
25869 
  def read(self, iprot):
25870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25872 
      return
25873 
    iprot.readStructBegin()
25874 
    while True:
25875 
      (fname, ftype, fid) = iprot.readFieldBegin()
25876 
      if ftype == TType.STOP:
25877 
        break
25878 
      if fid == 0:
25879 
        if ftype == TType.STRUCT:
25880 
          self.success = RechargeResponse()
25881 
          self.success.read(iprot)
25882 
        else:
25883 
          iprot.skip(ftype)
25884 
      elif fid == 1:
25885 
        if ftype == TType.STRUCT:
25886 
          self.ex = TransactionServiceException()
25887 
          self.ex.read(iprot)
25888 
        else:
25889 
          iprot.skip(ftype)
25890 
      else:
25891 
        iprot.skip(ftype)
25892 
      iprot.readFieldEnd()
25893 
    iprot.readStructEnd()
25894 
 
25895 
  def write(self, oprot):
25896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25898 
      return
25899 
    oprot.writeStructBegin('activateRechargeTxn_result')
25900 
    if self.success is not None:
25901 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25902 
      self.success.write(oprot)
25903 
      oprot.writeFieldEnd()
25904 
    if self.ex is not None:
25905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25906 
      self.ex.write(oprot)
25907 
      oprot.writeFieldEnd()
25908 
    oprot.writeFieldStop()
25909 
    oprot.writeStructEnd()
25910 
 
25911 
  def validate(self):
25912 
    return
25913 
 
25914 
 
25915 
  def __repr__(self):
25916 
    L = ['%s=%r' % (key, value)
25917 
      for key, value in self.__dict__.iteritems()]
25918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25919 
 
25920 
  def __eq__(self, other):
25921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25922 
 
25923 
  def __ne__(self, other):
25924 
    return not (self == other)
25925 
 
25926 
class getRechargeOrders_args:
25927 
  """
25928 
  Attributes:
25929 
   - customerId
25930 
  """
25931 
 
25932 
  thrift_spec = (
25933 
    None, # 0
25934 
    (1, TType.I64, 'customerId', None, None, ), # 1
25935 
  )
25936 
 
25937 
  def __init__(self, customerId=None,):
25938 
    self.customerId = customerId
25939 
 
25940 
  def read(self, iprot):
25941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25943 
      return
25944 
    iprot.readStructBegin()
25945 
    while True:
25946 
      (fname, ftype, fid) = iprot.readFieldBegin()
25947 
      if ftype == TType.STOP:
25948 
        break
25949 
      if fid == 1:
25950 
        if ftype == TType.I64:
25951 
          self.customerId = iprot.readI64();
25952 
        else:
25953 
          iprot.skip(ftype)
25954 
      else:
25955 
        iprot.skip(ftype)
25956 
      iprot.readFieldEnd()
25957 
    iprot.readStructEnd()
25958 
 
25959 
  def write(self, oprot):
25960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25962 
      return
25963 
    oprot.writeStructBegin('getRechargeOrders_args')
25964 
    if self.customerId is not None:
25965 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
25966 
      oprot.writeI64(self.customerId)
25967 
      oprot.writeFieldEnd()
25968 
    oprot.writeFieldStop()
25969 
    oprot.writeStructEnd()
25970 
 
25971 
  def validate(self):
25972 
    return
25973 
 
25974 
 
25975 
  def __repr__(self):
25976 
    L = ['%s=%r' % (key, value)
25977 
      for key, value in self.__dict__.iteritems()]
25978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25979 
 
25980 
  def __eq__(self, other):
25981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25982 
 
25983 
  def __ne__(self, other):
25984 
    return not (self == other)
25985 
 
25986 
class getRechargeOrders_result:
25987 
  """
25988 
  Attributes:
25989 
   - success
25990 
  """
25991 
 
25992 
  thrift_spec = (
25993 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
25994 
  )
25995 
 
25996 
  def __init__(self, success=None,):
25997 
    self.success = success
25998 
 
25999 
  def read(self, iprot):
26000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26002 
      return
26003 
    iprot.readStructBegin()
26004 
    while True:
26005 
      (fname, ftype, fid) = iprot.readFieldBegin()
26006 
      if ftype == TType.STOP:
26007 
        break
26008 
      if fid == 0:
26009 
        if ftype == TType.LIST:
26010 
          self.success = []
26011 
          (_etype630, _size627) = iprot.readListBegin()
26012 
          for _i631 in xrange(_size627):
26013 
            _elem632 = RechargeOrder()
26014 
            _elem632.read(iprot)
26015 
            self.success.append(_elem632)
26016 
          iprot.readListEnd()
26017 
        else:
26018 
          iprot.skip(ftype)
26019 
      else:
26020 
        iprot.skip(ftype)
26021 
      iprot.readFieldEnd()
26022 
    iprot.readStructEnd()
26023 
 
26024 
  def write(self, oprot):
26025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26027 
      return
26028 
    oprot.writeStructBegin('getRechargeOrders_result')
26029 
    if self.success is not None:
26030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26032 
      for iter633 in self.success:
26033 
        iter633.write(oprot)
26034 
      oprot.writeListEnd()
26035 
      oprot.writeFieldEnd()
26036 
    oprot.writeFieldStop()
26037 
    oprot.writeStructEnd()
26038 
 
26039 
  def validate(self):
26040 
    return
26041 
 
26042 
 
26043 
  def __repr__(self):
26044 
    L = ['%s=%r' % (key, value)
26045 
      for key, value in self.__dict__.iteritems()]
26046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26047 
 
26048 
  def __eq__(self, other):
26049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26050 
 
26051 
  def __ne__(self, other):
26052 
    return not (self == other)
26053 
 
26054 
class getRechargeCoupons_args:
26055 
  """
26056 
  Attributes:
26057 
   - customerId
26058 
   - rechargeCouponStatus
26059 
  """
26060 
 
26061 
  thrift_spec = (
26062 
    None, # 0
26063 
    (1, TType.I64, 'customerId', None, None, ), # 1
26064 
    (2, TType.I32, 'rechargeCouponStatus', None, None, ), # 2
26065 
  )
26066 
 
26067 
  def __init__(self, customerId=None, rechargeCouponStatus=None,):
26068 
    self.customerId = customerId
26069 
    self.rechargeCouponStatus = rechargeCouponStatus
26070 
 
26071 
  def read(self, iprot):
26072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26074 
      return
26075 
    iprot.readStructBegin()
26076 
    while True:
26077 
      (fname, ftype, fid) = iprot.readFieldBegin()
26078 
      if ftype == TType.STOP:
26079 
        break
26080 
      if fid == 1:
26081 
        if ftype == TType.I64:
26082 
          self.customerId = iprot.readI64();
26083 
        else:
26084 
          iprot.skip(ftype)
26085 
      elif fid == 2:
26086 
        if ftype == TType.I32:
26087 
          self.rechargeCouponStatus = iprot.readI32();
26088 
        else:
26089 
          iprot.skip(ftype)
26090 
      else:
26091 
        iprot.skip(ftype)
26092 
      iprot.readFieldEnd()
26093 
    iprot.readStructEnd()
26094 
 
26095 
  def write(self, oprot):
26096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26098 
      return
26099 
    oprot.writeStructBegin('getRechargeCoupons_args')
26100 
    if self.customerId is not None:
26101 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
26102 
      oprot.writeI64(self.customerId)
26103 
      oprot.writeFieldEnd()
26104 
    if self.rechargeCouponStatus is not None:
26105 
      oprot.writeFieldBegin('rechargeCouponStatus', TType.I32, 2)
26106 
      oprot.writeI32(self.rechargeCouponStatus)
26107 
      oprot.writeFieldEnd()
26108 
    oprot.writeFieldStop()
26109 
    oprot.writeStructEnd()
26110 
 
26111 
  def validate(self):
26112 
    return
26113 
 
26114 
 
26115 
  def __repr__(self):
26116 
    L = ['%s=%r' % (key, value)
26117 
      for key, value in self.__dict__.iteritems()]
26118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26119 
 
26120 
  def __eq__(self, other):
26121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26122 
 
26123 
  def __ne__(self, other):
26124 
    return not (self == other)
26125 
 
26126 
class getRechargeCoupons_result:
26127 
  """
26128 
  Attributes:
26129 
   - success
26130 
  """
26131 
 
26132 
  thrift_spec = (
26133 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeCoupon, RechargeCoupon.thrift_spec)), None, ), # 0
26134 
  )
26135 
 
26136 
  def __init__(self, success=None,):
26137 
    self.success = success
26138 
 
26139 
  def read(self, iprot):
26140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26142 
      return
26143 
    iprot.readStructBegin()
26144 
    while True:
26145 
      (fname, ftype, fid) = iprot.readFieldBegin()
26146 
      if ftype == TType.STOP:
26147 
        break
26148 
      if fid == 0:
26149 
        if ftype == TType.LIST:
26150 
          self.success = []
26151 
          (_etype637, _size634) = iprot.readListBegin()
26152 
          for _i638 in xrange(_size634):
26153 
            _elem639 = RechargeCoupon()
26154 
            _elem639.read(iprot)
26155 
            self.success.append(_elem639)
26156 
          iprot.readListEnd()
26157 
        else:
26158 
          iprot.skip(ftype)
26159 
      else:
26160 
        iprot.skip(ftype)
26161 
      iprot.readFieldEnd()
26162 
    iprot.readStructEnd()
26163 
 
26164 
  def write(self, oprot):
26165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26167 
      return
26168 
    oprot.writeStructBegin('getRechargeCoupons_result')
26169 
    if self.success is not None:
26170 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26171 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26172 
      for iter640 in self.success:
26173 
        iter640.write(oprot)
26174 
      oprot.writeListEnd()
26175 
      oprot.writeFieldEnd()
26176 
    oprot.writeFieldStop()
26177 
    oprot.writeStructEnd()
26178 
 
26179 
  def validate(self):
26180 
    return
26181 
 
26182 
 
26183 
  def __repr__(self):
26184 
    L = ['%s=%r' % (key, value)
26185 
      for key, value in self.__dict__.iteritems()]
26186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26187 
 
26188 
  def __eq__(self, other):
26189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26190 
 
26191 
  def __ne__(self, other):
26192 
    return not (self == other)