Subversion Repositories SmartDukaan

Rev

Rev 5527 | Rev 5593 | 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 
 
281 
  def getValidOrders(self, limit):
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
288 
    """
289 
    pass
290 
 
1220 chandransh 291 
  def batchOrders(self, warehouseId):
292 
    """
293 
    Create a batch of all the pending orders for the given warehouse.
294 
    The returned list is orderd by created_timestamp.
295 
    If there are no pending orders, an empty list is returned.
3431 rajveer 296 
 
1220 chandransh 297 
    Parameters:
298 
     - warehouseId
299 
    """
300 
    pass
301 
 
1208 chandransh 302 
  def markOrderAsOutOfStock(self, orderId):
303 
    """
304 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 305 
 
1208 chandransh 306 
    Parameters:
307 
     - orderId
308 
    """
309 
    pass
310 
 
3064 chandransh 311 
  def verifyOrder(self, orderId):
759 chandransh 312 
    """
3064 chandransh 313 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
314 
    timestamp. It is intended to be used for COD orders but can be harmlessly
315 
    used for all other orders as well.
316 
    Throws an exception if no such order exists.
3431 rajveer 317 
 
759 chandransh 318 
    Parameters:
3064 chandransh 319 
     - orderId
320 
    """
321 
    pass
322 
 
323 
  def acceptOrder(self, orderId):
324 
    """
325 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
326 
    given order is not a COD order, it also captures the payment if the same has
327 
    not been captured.
328 
    Throws an exception if no such order exists.
3431 rajveer 329 
 
3064 chandransh 330 
    Parameters:
331 
     - orderId
332 
    """
333 
    pass
334 
 
5110 mandeep.dh 335 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 336 
    """
337 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 338 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 339 
    the IMEI no. if a -1 is supplied.
340 
    Also, it generates an invoice number for the order, marks the order as
341 
    BILLED and sets the billing timestamp.
342 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 343 
 
3064 chandransh 344 
    Parameters:
345 
     - orderId
4283 anupam.sin 346 
     - invoice_number
4658 mandeep.dh 347 
     - serialNumber
3064 chandransh 348 
     - itemNumber
4283 anupam.sin 349 
     - billed_by
350 
     - jacketNumber
3064 chandransh 351 
     - billingType
5110 mandeep.dh 352 
     - fulfilmentWarehouseId
4763 rajveer 353 
     - authorize
3064 chandransh 354 
    """
355 
    pass
356 
 
4763 rajveer 357 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 358 
    """
359 
    Add the invoice number to the order.
360 
 
361 
    Parameters:
362 
     - orderId
363 
     - invoiceNumber
4763 rajveer 364 
     - color
4579 rajveer 365 
    """
366 
    pass
367 
 
4910 phani.kuma 368 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 369 
    """
370 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 371 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 372 
 
373 
    Parameters:
374 
     - warehouseId
375 
     - providerId
376 
     - cod
4910 phani.kuma 377 
     - orderIds
4410 rajveer 378 
    """
379 
    pass
380 
 
4910 phani.kuma 381 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 382 
    """
4910 phani.kuma 383 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
384 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 385 
 
3064 chandransh 386 
    Parameters:
759 chandransh 387 
     - providerId
4910 phani.kuma 388 
     - pickupDetails
759 chandransh 389 
    """
390 
    pass
391 
 
4910 phani.kuma 392 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 393 
    """
394 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 395 
 
1113 chandransh 396 
    Parameters:
397 
     - providerId
398 
    """
399 
    pass
400 
 
1132 chandransh 401 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
402 
    """
403 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
404 
    the name of the receiver.
405 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 406 
 
1132 chandransh 407 
    Parameters:
408 
     - providerId
409 
     - deliveredOrders
410 
    """
411 
    pass
412 
 
4910 phani.kuma 413 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 414 
    """
4910 phani.kuma 415 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 416 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 417 
 
1135 chandransh 418 
    Parameters:
419 
     - providerId
420 
     - returnedOrders
421 
    """
422 
    pass
423 
 
4910 phani.kuma 424 
  def getRTOrders(self, providerId):
425 
    """
426 
    Returns a list of orders that were returned by courier.
427 
 
428 
    Parameters:
429 
     - providerId
430 
    """
431 
    pass
432 
 
1246 chandransh 433 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
434 
    """
435 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 436 
 
1246 chandransh 437 
    Parameters:
438 
     - providerId
439 
     - undeliveredOrders
440 
    """
441 
    pass
442 
 
4910 phani.kuma 443 
  def getNonDeliveredOrdersbyCourier(self, providerId):
444 
    """
445 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
446 
 
447 
    Parameters:
448 
     - providerId
449 
    """
450 
    pass
451 
 
452 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
453 
    """
454 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
455 
 
456 
    Parameters:
457 
     - providerId
458 
     - local_connected_orders
459 
    """
460 
    pass
461 
 
462 
  def getOrdersNotLocalConnected(self, providerId):
463 
    """
464 
    Returns a list of orders that were picked up or shipped but pending local connection.
465 
 
466 
    Parameters:
467 
     - providerId
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - destination_city_reached_orders
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - first_atdl_orders
488 
    """
489 
    pass
490 
 
1408 ankur.sing 491 
  def getUndeliveredOrders(self, providerId, warehouseId):
492 
    """
493 
    Returns the list of orders whose delivery time has passed but have not been
494 
    delivered yet for the given provider and warehouse. To get a complete list of
495 
    undelivered orders, pass them as -1.
496 
    Returns an empty list if no such orders exist.
3431 rajveer 497 
 
1408 ankur.sing 498 
    Parameters:
499 
     - providerId
500 
     - warehouseId
501 
    """
502 
    pass
503 
 
4783 phani.kuma 504 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
505 
    """
506 
    Returns the list of orders whose expected delivery date has passed but have not been
507 
    delivered yet.
508 
    Returns an empty list if no such orders exist.
509 
    """
510 
    pass
511 
 
2536 chandransh 512 
  def toggleDOAFlag(self, orderId):
513 
    """
514 
    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.
515 
    Returns the final flag status.
516 
    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 517 
 
2536 chandransh 518 
    Parameters:
519 
     - orderId
520 
    """
521 
    pass
1886 ankur.sing 522 
 
4712 rajveer 523 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
524 
    """
525 
    Parameters:
526 
     - orderId
527 
     - deliveryTimestamp
528 
     - receiver
529 
    """
530 
    pass
531 
 
5553 rajveer 532 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
533 
    """
534 
    Parameters:
535 
     - orderId
536 
     - deliveryTimestamp
537 
    """
538 
    pass
539 
 
4454 rajveer 540 
  def markOrderDoaRequestReceived(self, orderId):
541 
    """
542 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
543 
 
544 
    Parameters:
545 
     - orderId
546 
    """
547 
    pass
548 
 
549 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
550 
    """
551 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
552 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
553 
 
554 
    Parameters:
555 
     - orderId
556 
     - isAuthorized
557 
    """
558 
    pass
559 
 
4488 rajveer 560 
  def markOrderReturnRequestReceived(self, orderId):
561 
    """
562 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
563 
 
564 
    Parameters:
565 
     - orderId
566 
    """
567 
    pass
568 
 
569 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
570 
    """
571 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
572 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
573 
 
574 
    Parameters:
575 
     - orderId
576 
     - isAuthorized
577 
    """
578 
    pass
579 
 
4579 rajveer 580 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 581 
    """
582 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 583 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
584 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 585 
    For any other status, it returns false.
586 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 587 
 
2536 chandransh 588 
    Parameters:
589 
     - orderId
4579 rajveer 590 
     - providerId
2536 chandransh 591 
    """
592 
    pass
593 
 
4602 rajveer 594 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 595 
    """
4452 rajveer 596 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 597 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
598 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
599 
    	3. Returns true
2591 chandransh 600 
    If the order is in any other status, it returns false.
2536 chandransh 601 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 602 
 
2536 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - pickupNumber
4602 rajveer 606 
     - providerId
2536 chandransh 607 
    """
608 
    pass
609 
 
2764 chandransh 610 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
611 
    """
612 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 613 
 
2764 chandransh 614 
    Parameters:
615 
     - providerId
616 
     - pickupDetails
617 
    """
618 
    pass
619 
 
4910 phani.kuma 620 
  def getDoasNotPickedUp(self, providerId):
621 
    """
622 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
623 
 
624 
    Parameters:
625 
     - providerId
626 
    """
627 
    pass
628 
 
4741 phani.kuma 629 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
630 
    """
631 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
632 
 
633 
    Parameters:
634 
     - providerId
635 
     - pickupDetails
636 
    """
637 
    pass
638 
 
4910 phani.kuma 639 
  def getReturnOrdersNotPickedUp(self, providerId):
640 
    """
641 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
642 
 
643 
    Parameters:
644 
     - providerId
645 
    """
646 
    pass
647 
 
4479 rajveer 648 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 649 
    """
4452 rajveer 650 
    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 651 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 652 
    If the order is in any other state, it returns false.
653 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 654 
 
2591 chandransh 655 
    Parameters:
656 
     - orderId
4479 rajveer 657 
     - receiveCondition
2591 chandransh 658 
    """
659 
    pass
2536 chandransh 660 
 
2591 chandransh 661 
  def validateDoa(self, orderId, isValid):
662 
    """
4452 rajveer 663 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 664 
    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 665 
    If the order is in any other state, it returns false.
666 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 667 
 
2591 chandransh 668 
    Parameters:
669 
     - orderId
670 
     - isValid
671 
    """
672 
    pass
673 
 
4495 rajveer 674 
  def validateReturnProduct(self, orderId, isUsable):
675 
    """
676 
    Parameters:
677 
     - orderId
678 
     - isUsable
679 
    """
680 
    pass
681 
 
2616 chandransh 682 
  def reshipOrder(self, orderId):
683 
    """
4484 rajveer 684 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 685 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 686 
    	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 687 
 
688 
    If the order is in DOA_CERT_VALID state, it does the following:
689 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
690 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 691 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 692 
 
2616 chandransh 693 
    Returns the id of the newly created order.
3431 rajveer 694 
 
2616 chandransh 695 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 696 
 
2616 chandransh 697 
    Parameters:
698 
     - orderId
699 
    """
700 
    pass
2591 chandransh 701 
 
3226 chandransh 702 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 703 
    """
4484 rajveer 704 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 705 
    	1. Creates a refund request for batch processing.
706 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 707 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 708 
 
2616 chandransh 709 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
710 
    	1. Creates a refund request for batch processing.
3226 chandransh 711 
    	2. Cancels the reservation of the item in the warehouse.
712 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 713 
 
3226 chandransh 714 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
715 
    	1. Cancels the reservation of the item in the warehouse.
716 
    	2. Marks the current order as CANCELED.
717 
 
718 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
719 
 
2616 chandransh 720 
    Returns True if it is successful, False otherwise.
3431 rajveer 721 
 
2616 chandransh 722 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 723 
 
2616 chandransh 724 
    Parameters:
725 
     - orderId
3226 chandransh 726 
     - refundedBy
727 
     - reason
2616 chandransh 728 
    """
729 
    pass
730 
 
2690 chandransh 731 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
732 
    """
733 
    Get all return orders created between the from and to dates for the given warehouse.
734 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 735 
 
2690 chandransh 736 
    Parameters:
737 
     - warehouseId
738 
     - fromDate
739 
     - toDate
740 
    """
741 
    pass
2616 chandransh 742 
 
5481 phani.kuma 743 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates.
746 
 
747 
    Parameters:
748 
     - onlyNotProcessed
749 
     - fromDate
750 
     - toDate
751 
    """
752 
    pass
753 
 
2700 chandransh 754 
  def getReturnOrder(self, id):
755 
    """
756 
    Returns the ReturnOrder corresponding to the given id.
757 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 758 
 
2700 chandransh 759 
    Parameters:
760 
     - id
761 
    """
762 
    pass
763 
 
2690 chandransh 764 
  def processReturn(self, returnOrderId):
765 
    """
766 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 767 
 
2690 chandransh 768 
    Parameters:
769 
     - returnOrderId
770 
    """
771 
    pass
772 
 
3451 chandransh 773 
  def updateWeight(self, orderId, weight):
774 
    """
775 
    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 776 
 
3451 chandransh 777 
    Parameters:
778 
     - orderId
779 
     - weight
780 
    """
781 
    pass
782 
 
3469 chandransh 783 
  def changeItem(self, orderId, itemId):
784 
    """
785 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
786 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 787 
 
3469 chandransh 788 
    Parameters:
789 
     - orderId
790 
     - itemId
791 
    """
792 
    pass
793 
 
794 
  def shiftToWarehouse(self, orderId, warehouseId):
795 
    """
796 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
797 
 
798 
    Parameters:
799 
     - orderId
800 
     - warehouseId
801 
    """
802 
    pass
803 
 
4647 rajveer 804 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 805 
    """
806 
    Adds the given delay reason to the given order.
3986 chandransh 807 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 808 
    Raises an exception if no order with the given id can be found.
3469 chandransh 809 
 
3553 chandransh 810 
    Parameters:
811 
     - orderId
812 
     - delayReason
3986 chandransh 813 
     - furtherDelay
4647 rajveer 814 
     - delayReasonText
3553 chandransh 815 
    """
816 
    pass
817 
 
3956 chandransh 818 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
819 
    """
820 
    Marks the COD orders with given AWB nos. as having been processed.
821 
    Updates the captured amount for the corresponding payment.
3553 chandransh 822 
 
3956 chandransh 823 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
824 
    1. There is no order corresponding to an AWB number.
825 
    2. The captured amount for a payment exceeds the total payment.
826 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
827 
 
828 
    Parameters:
829 
     - collectedAmountMap
830 
     - xferBy
831 
     - xferTxnId
832 
     - xferDate
833 
    """
834 
    pass
835 
 
4008 mandeep.dh 836 
  def getTransactionsRequiringExtraProcessing(self, category):
837 
    """
4065 mandeep.dh 838 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 839 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 840 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 841 
 
4008 mandeep.dh 842 
    Parameters:
843 
     - category
844 
    """
845 
    pass
846 
 
847 
  def markTransactionAsProcessed(self, transactionId, category):
848 
    """
849 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 850 
    It essentially deletes the transaction id record for a particular
851 
    processing type category (if present) from DB.
852 
    This is currently used by CRM application.
4008 mandeep.dh 853 
 
854 
    Parameters:
855 
     - transactionId
856 
     - category
857 
    """
858 
    pass
859 
 
4018 chandransh 860 
  def getItemWiseRiskyOrdersCount(self, ):
861 
    """
862 
    Returns a map containing the number of risky orders keyed by item id. A risky order
863 
    is defined as one whose shipping date is about to expire.
864 
    """
865 
    pass
4008 mandeep.dh 866 
 
4295 varun.gupt 867 
  def getOrdersForItemIds(self, itemIds):
868 
    """
869 
    Returns a list of all orders which have items with given id
870 
 
871 
    Parameters:
872 
     - itemIds
873 
    """
874 
    pass
875 
 
4247 rajveer 876 
  def markOrderCancellationRequestReceived(self, orderId):
877 
    """
878 
    Mark order as cancellation request received. If customer sends request of cancellation of
879 
    a particular order, this method will be called. It will just change status of the order
880 
    depending on its current status. It also records the previous status, so that we can move
881 
    back to that status if cancellation request is denied.
4018 chandransh 882 
 
4247 rajveer 883 
    Parameters:
884 
     - orderId
885 
    """
886 
    pass
887 
 
888 
  def markOrderCancellationRequestConfirmed(self, orderId):
889 
    """
890 
    If we decide to to cancel order, CRM will call this method to move the status of order to
891 
    cancellation request confirmed. After this OM will be able to cancel the order.
892 
 
893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestDenied(self, orderId):
899 
    """
900 
    If we decide to not to cancel order, we will move the order ro previous status.
901 
 
902 
    Parameters:
903 
     - orderId
904 
    """
905 
    pass
906 
 
4258 rajveer 907 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 908 
    """
4258 rajveer 909 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
910 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 911 
 
912 
    Parameters:
4258 rajveer 913 
     - transactionId
4247 rajveer 914 
    """
915 
    pass
916 
 
4259 anupam.sin 917 
  def refundTransaction(self, transactionId, refundedBy, reason):
918 
    """
919 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
920 
    need to be cancelled
4247 rajveer 921 
 
4259 anupam.sin 922 
    Parameters:
923 
     - transactionId
924 
     - refundedBy
925 
     - reason
926 
    """
927 
    pass
928 
 
4324 mandeep.dh 929 
  def updateShipmentAddress(self, orderId, addressId):
930 
    """
931 
    Updates shipment address of an order. Delivery and shipping date estimates
932 
    etc. are also updated here.
933 
 
934 
    Throws TransactionServiceException in case address change is not
935 
    possible due to certain reasons such as new pincode in address is
936 
    not serviceable etc.
937 
 
938 
    Parameters:
939 
     - orderId
940 
     - addressId
941 
    """
942 
    pass
943 
 
4285 rajveer 944 
  def acceptOrdersForItemId(self, itemId, inventory):
945 
    """
946 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
947 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 948 
 
4285 rajveer 949 
    Parameters:
950 
     - itemId
951 
     - inventory
952 
    """
953 
    pass
954 
 
4369 rajveer 955 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 956 
    """
957 
    Parameters:
958 
     - vendorId
959 
     - itemId
960 
     - quantity
961 
     - estimate
4369 rajveer 962 
     - isReminder
4303 rajveer 963 
    """
964 
    pass
4285 rajveer 965 
 
4369 rajveer 966 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 967 
    """
968 
    Parameters:
969 
     - vendorId
970 
     - itemId
971 
     - quantity
972 
     - estimate
4369 rajveer 973 
     - isReminder
4303 rajveer 974 
    """
975 
    pass
976 
 
4369 rajveer 977 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 978 
    """
979 
    Parameters:
980 
     - vendorId
981 
     - itemId
982 
     - quantity
983 
     - estimate
4369 rajveer 984 
     - isReminder
4303 rajveer 985 
    """
986 
    pass
987 
 
4369 rajveer 988 
  def markOrdersAsTimeout(self, vendorId):
989 
    """
990 
    Parameters:
991 
     - vendorId
992 
    """
993 
    pass
4303 rajveer 994 
 
4662 rajveer 995 
  def markOrderAsLostInTransit(self, orderId):
996 
    """
997 
    Mark order as LOST_IN_TRANSIT
998 
 
999 
    Parameters:
1000 
     - orderId
1001 
    """
1002 
    pass
1003 
 
4386 anupam.sin 1004 
  def getOrderForAwb(self, awb):
1005 
    """
1006 
    Returns the order corresponding to an AWB number
4369 rajveer 1007 
 
4386 anupam.sin 1008 
    Parameters:
1009 
     - awb
1010 
    """
1011 
    pass
1012 
 
4910 phani.kuma 1013 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1014 
    """
4910 phani.kuma 1015 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1016 
 
4506 phani.kuma 1017 
    Parameters:
1018 
     - logistics_provider_id
4910 phani.kuma 1019 
     - order_status_list
4506 phani.kuma 1020 
    """
1021 
    pass
1022 
 
4600 varun.gupt 1023 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1024 
    """
1025 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1026 
 
4600 varun.gupt 1027 
    Parameters:
1028 
     - vendorId
1029 
     - billingDateFrom
1030 
     - billingDateTo
1031 
    """
1032 
    pass
1033 
 
4607 rajveer 1034 
  def getSlippedSippingDateOrders(self, ):
1035 
    pass
1036 
 
4709 rajveer 1037 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1038 
    """
1039 
    Parameters:
1040 
     - cancelDateFrom
1041 
     - cancelDateTo
1042 
    """
1043 
    pass
1044 
 
4600 varun.gupt 1045 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1046 
    """
1047 
    Parameters:
1048 
     - mapAWBAndAmount
1049 
    """
1050 
    pass
1051 
 
4905 varun.gupt 1052 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1053 
    """
1054 
    Parameters:
1055 
     - settlementDate
1056 
     - paymentGatewayId
4905 varun.gupt 1057 
     - referenceId
4600 varun.gupt 1058 
     - serviceTax
1059 
     - otherCharges
1060 
     - netCollection
1061 
    """
1062 
    pass
1063 
 
1064 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1065 
    """
1066 
    Parameters:
1067 
     - settlementId
1068 
     - settlementDate
1069 
     - transactionDateFrom
1070 
     - transactionDateTo
1071 
     - amount
1072 
    """
1073 
    pass
1074 
 
5386 phani.kuma 1075 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1076 
    """
1077 
    Parameters:
5189 varun.gupt 1078 
     - referenceId
1079 
     - isRefund
4600 varun.gupt 1080 
    """
1081 
    pass
1082 
 
5386 phani.kuma 1083 
  def getSettlementForCod(self, orderId, isRefund):
1084 
    """
1085 
    Parameters:
1086 
     - orderId
1087 
     - isRefund
1088 
    """
1089 
    pass
1090 
 
4600 varun.gupt 1091 
  def getEBSSettlementSummaries(self, ):
1092 
    pass
1093 
 
1094 
  def markEBSSettlementUploaded(self, settlementId):
1095 
    """
1096 
    Parameters:
1097 
     - settlementId
1098 
    """
1099 
    pass
1100 
 
1101 
  def getEBSSettlementDate(self, settlementId):
1102 
    """
1103 
    Parameters:
1104 
     - settlementId
1105 
    """
1106 
    pass
1107 
 
4715 varun.gupt 1108 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1109 
    """
1110 
    Parameters:
1111 
     - settlementDateFrom
1112 
     - settlementDateTo
1113 
     - isRefund
1114 
    """
1115 
    pass
4600 varun.gupt 1116 
 
4715 varun.gupt 1117 
  def getReshippedOrderIds(self, orderIds):
1118 
    """
1119 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1120 
 
1121 
    Parameters:
1122 
     - orderIds
1123 
    """
1124 
    pass
1125 
 
5481 phani.kuma 1126 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1127 
    """
1128 
    Parameters:
1129 
     - vendorId
5481 phani.kuma 1130 
     - onlyVendorNotPaid
1131 
     - billingDateFrom
1132 
     - billingDateTo
4875 varun.gupt 1133 
    """
1134 
    pass
4757 mandeep.dh 1135 
 
5031 varun.gupt 1136 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1137 
    """
1138 
    Parameters:
1139 
     - startDate
1140 
     - endDate
1141 
    """
1142 
    pass
4875 varun.gupt 1143 
 
5067 varun.gupt 1144 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1145 
    """
1146 
    Parameters:
1147 
     - status
1148 
     - startDatetime
1149 
     - endDatetime
1150 
    """
1151 
    pass
5031 varun.gupt 1152 
 
5348 anupam.sin 1153 
  def updateCODAgent(self, agent, orderId):
1154 
    """
1155 
    Updates the agent who handled the COD verification call
1156 
 
1157 
    Parameters:
1158 
     - agent
1159 
     - orderId
1160 
    """
1161 
    pass
1162 
 
5099 varun.gupt 1163 
  def updateOrderAsPaidToVendor(self, orderId):
1164 
    """
1165 
    Parameters:
1166 
     - orderId
1167 
    """
1168 
    pass
5067 varun.gupt 1169 
 
5386 phani.kuma 1170 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1171 
    """
1172 
    Parameters:
1173 
     - orderId
1174 
    """
1175 
    pass
1176 
 
5208 varun.gupt 1177 
  def getRefundedOrdersMarkedPaid(self, ):
1178 
    pass
5099 varun.gupt 1179 
 
5447 anupam.sin 1180 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1181 
    """
1182 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1183 
 
5447 anupam.sin 1184 
 
1185 
    Parameters:
1186 
     - minOrderId
1187 
     - maxOrderId
1188 
    """
1189 
    pass
1190 
 
5527 anupam.sin 1191 
  def getAllAttributesForOrderId(self, orderId):
1192 
    """
1193 
    gets all attributes for a given orderId
5447 anupam.sin 1194 
 
5527 anupam.sin 1195 
    Parameters:
1196 
     - orderId
1197 
    """
1198 
    pass
1199 
 
1200 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1201 
    """
1202 
    sets attributes for all orders in a transaction
1203 
 
1204 
    Parameters:
1205 
     - transactionId
1206 
     - attribute
1207 
    """
1208 
    pass
1209 
 
5553 rajveer 1210 
  def getReceivePendingOrders(self, storeId):
1211 
    """
1212 
    Parameters:
1213 
     - storeId
1214 
    """
1215 
    pass
5527 anupam.sin 1216 
 
5553 rajveer 1217 
  def getReceivedAtStoreOrders(self, storeId):
1218 
    """
1219 
    Parameters:
1220 
     - storeId
1221 
    """
1222 
    pass
1223 
 
1224 
 
3376 rajveer 1225 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1226 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1227 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1228 
 
1229 
  def createTransaction(self, transaction):
1230 
    """
1231 
    Parameters:
1232 
     - transaction
1233 
    """
1234 
    self.send_createTransaction(transaction)
132 ashish 1235 
    return self.recv_createTransaction()
94 ashish 1236 
 
1237 
  def send_createTransaction(self, transaction):
1238 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1239 
    args = createTransaction_args()
1240 
    args.transaction = transaction
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_createTransaction(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = createTransaction_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
3431 rajveer 1255 
    if result.success is not None:
132 ashish 1256 
      return result.success
3431 rajveer 1257 
    if result.ex is not None:
94 ashish 1258 
      raise result.ex
132 ashish 1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1260 
 
1261 
  def getTransaction(self, id):
1262 
    """
1263 
    Parameters:
1264 
     - id
1265 
    """
1266 
    self.send_getTransaction(id)
1267 
    return self.recv_getTransaction()
1268 
 
1269 
  def send_getTransaction(self, id):
1270 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1271 
    args = getTransaction_args()
1272 
    args.id = id
1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
1277 
  def recv_getTransaction(self, ):
1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
1284 
    result = getTransaction_result()
1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
3431 rajveer 1287 
    if result.success is not None:
94 ashish 1288 
      return result.success
3431 rajveer 1289 
    if result.ex is not None:
94 ashish 1290 
      raise result.ex
1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1292 
 
1293 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1294 
    """
1295 
    Parameters:
1296 
     - customerId
1297 
     - from_date
1298 
     - to_date
1299 
     - status
1300 
    """
1301 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1302 
    return self.recv_getTransactionsForCustomer()
1303 
 
1304 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1305 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1306 
    args = getTransactionsForCustomer_args()
1307 
    args.customerId = customerId
1308 
    args.from_date = from_date
1309 
    args.to_date = to_date
1310 
    args.status = status
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_getTransactionsForCustomer(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = getTransactionsForCustomer_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
3431 rajveer 1325 
    if result.success is not None:
94 ashish 1326 
      return result.success
3431 rajveer 1327 
    if result.ex is not None:
94 ashish 1328 
      raise result.ex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1330 
 
132 ashish 1331 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1332 
    """
1333 
    Parameters:
1334 
     - shoppingCartId
1335 
    """
1336 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1337 
    return self.recv_getTransactionsForShoppingCartId()
1338 
 
1339 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1340 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1341 
    args = getTransactionsForShoppingCartId_args()
1342 
    args.shoppingCartId = shoppingCartId
1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1347 
  def recv_getTransactionsForShoppingCartId(self, ):
1348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1349 
    if mtype == TMessageType.EXCEPTION:
1350 
      x = TApplicationException()
1351 
      x.read(self._iprot)
1352 
      self._iprot.readMessageEnd()
1353 
      raise x
1354 
    result = getTransactionsForShoppingCartId_result()
1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
3431 rajveer 1357 
    if result.success is not None:
132 ashish 1358 
      return result.success
3431 rajveer 1359 
    if result.ex is not None:
132 ashish 1360 
      raise result.ex
1361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1362 
 
94 ashish 1363 
  def getTransactionStatus(self, transactionId):
1364 
    """
1365 
    Parameters:
1366 
     - transactionId
1367 
    """
1368 
    self.send_getTransactionStatus(transactionId)
1369 
    return self.recv_getTransactionStatus()
1370 
 
1371 
  def send_getTransactionStatus(self, transactionId):
1372 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1373 
    args = getTransactionStatus_args()
1374 
    args.transactionId = transactionId
1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1379 
  def recv_getTransactionStatus(self, ):
1380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1381 
    if mtype == TMessageType.EXCEPTION:
1382 
      x = TApplicationException()
1383 
      x.read(self._iprot)
1384 
      self._iprot.readMessageEnd()
1385 
      raise x
1386 
    result = getTransactionStatus_result()
1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
3431 rajveer 1389 
    if result.success is not None:
94 ashish 1390 
      return result.success
3431 rajveer 1391 
    if result.ex is not None:
94 ashish 1392 
      raise result.ex
1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1394 
 
5527 anupam.sin 1395 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1396 
    """
1397 
    Parameters:
1398 
     - transactionId
1399 
     - status
1400 
     - description
5527 anupam.sin 1401 
     - pickUp
1402 
     - orderType
94 ashish 1403 
    """
5527 anupam.sin 1404 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1405 
    return self.recv_changeTransactionStatus()
1406 
 
5527 anupam.sin 1407 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1408 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1409 
    args = changeTransactionStatus_args()
1410 
    args.transactionId = transactionId
1411 
    args.status = status
1412 
    args.description = description
5527 anupam.sin 1413 
    args.pickUp = pickUp
1414 
    args.orderType = orderType
94 ashish 1415 
    args.write(self._oprot)
1416 
    self._oprot.writeMessageEnd()
1417 
    self._oprot.trans.flush()
1418 
 
1419 
  def recv_changeTransactionStatus(self, ):
1420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1421 
    if mtype == TMessageType.EXCEPTION:
1422 
      x = TApplicationException()
1423 
      x.read(self._iprot)
1424 
      self._iprot.readMessageEnd()
1425 
      raise x
1426 
    result = changeTransactionStatus_result()
1427 
    result.read(self._iprot)
1428 
    self._iprot.readMessageEnd()
3431 rajveer 1429 
    if result.success is not None:
94 ashish 1430 
      return result.success
3431 rajveer 1431 
    if result.ex is not None:
94 ashish 1432 
      raise result.ex
1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1434 
 
1398 varun.gupt 1435 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1436 
    """
1437 
    Parameters:
1438 
     - transactionId
1439 
    """
1398 varun.gupt 1440 
    self.send_enqueueTransactionInfoEmail(transactionId)
1441 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1442 
 
1398 varun.gupt 1443 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1444 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1445 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1446 
    args.transactionId = transactionId
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1398 varun.gupt 1451 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1398 varun.gupt 1458 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
3431 rajveer 1461 
    if result.success is not None:
1382 varun.gupt 1462 
      return result.success
3431 rajveer 1463 
    if result.ex is not None:
1382 varun.gupt 1464 
      raise result.ex
1398 varun.gupt 1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1466 
 
4801 anupam.sin 1467 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1468 
    """
1469 
    Parameters:
4801 anupam.sin 1470 
     - statuses
483 rajveer 1471 
     - from_date
1472 
     - to_date
1473 
     - warehouse_id
94 ashish 1474 
    """
4801 anupam.sin 1475 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1476 
    return self.recv_getAllOrders()
94 ashish 1477 
 
4801 anupam.sin 1478 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1479 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1480 
    args = getAllOrders_args()
4801 anupam.sin 1481 
    args.statuses = statuses
483 rajveer 1482 
    args.from_date = from_date
1483 
    args.to_date = to_date
1484 
    args.warehouse_id = warehouse_id
94 ashish 1485 
    args.write(self._oprot)
1486 
    self._oprot.writeMessageEnd()
1487 
    self._oprot.trans.flush()
1488 
 
483 rajveer 1489 
  def recv_getAllOrders(self, ):
94 ashish 1490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1491 
    if mtype == TMessageType.EXCEPTION:
1492 
      x = TApplicationException()
1493 
      x.read(self._iprot)
1494 
      self._iprot.readMessageEnd()
1495 
      raise x
483 rajveer 1496 
    result = getAllOrders_result()
94 ashish 1497 
    result.read(self._iprot)
1498 
    self._iprot.readMessageEnd()
3431 rajveer 1499 
    if result.success is not None:
94 ashish 1500 
      return result.success
3431 rajveer 1501 
    if result.ex is not None:
94 ashish 1502 
      raise result.ex
483 rajveer 1503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1504 
 
4133 chandransh 1505 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1506 
    """
1507 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1508 
    Pass the status as null and the limit as 0 to ignore them.
1509 
 
1510 
    Parameters:
1511 
     - statuses
1512 
     - offset
1513 
     - limit
1514 
     - warehouse_id
1515 
    """
1516 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1517 
    return self.recv_getOrdersInBatch()
1518 
 
1519 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1520 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1521 
    args = getOrdersInBatch_args()
1522 
    args.statuses = statuses
1523 
    args.offset = offset
1524 
    args.limit = limit
1525 
    args.warehouse_id = warehouse_id
1526 
    args.write(self._oprot)
1527 
    self._oprot.writeMessageEnd()
1528 
    self._oprot.trans.flush()
1529 
 
1530 
  def recv_getOrdersInBatch(self, ):
1531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1532 
    if mtype == TMessageType.EXCEPTION:
1533 
      x = TApplicationException()
1534 
      x.read(self._iprot)
1535 
      self._iprot.readMessageEnd()
1536 
      raise x
1537 
    result = getOrdersInBatch_result()
1538 
    result.read(self._iprot)
1539 
    self._iprot.readMessageEnd()
1540 
    if result.success is not None:
1541 
      return result.success
1542 
    if result.ex is not None:
1543 
      raise result.ex
1544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1545 
 
1546 
  def getOrderCount(self, statuses, warehouseId):
1547 
    """
1548 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1549 
 
1550 
    Parameters:
1551 
     - statuses
1552 
     - warehouseId
1553 
    """
1554 
    self.send_getOrderCount(statuses, warehouseId)
1555 
    return self.recv_getOrderCount()
1556 
 
1557 
  def send_getOrderCount(self, statuses, warehouseId):
1558 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1559 
    args = getOrderCount_args()
1560 
    args.statuses = statuses
1561 
    args.warehouseId = warehouseId
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_getOrderCount(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = getOrderCount_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
1576 
    if result.success is not None:
1577 
      return result.success
1578 
    if result.ex is not None:
1579 
      raise result.ex
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1581 
 
999 varun.gupt 1582 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1583 
    """
1132 chandransh 1584 
    Returns orders within a range of their billing dates
3431 rajveer 1585 
 
999 varun.gupt 1586 
    Parameters:
1587 
     - status
1588 
     - start_billing_date
1589 
     - end_billing_date
1590 
     - warehouse_id
1591 
    """
1592 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1593 
    return self.recv_getOrdersByBillingDate()
1594 
 
1595 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1596 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1597 
    args = getOrdersByBillingDate_args()
1598 
    args.status = status
1599 
    args.start_billing_date = start_billing_date
1600 
    args.end_billing_date = end_billing_date
1601 
    args.warehouse_id = warehouse_id
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getOrdersByBillingDate(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getOrdersByBillingDate_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
999 varun.gupt 1617 
      return result.success
3431 rajveer 1618 
    if result.ex is not None:
999 varun.gupt 1619 
      raise result.ex
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1621 
 
3451 chandransh 1622 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1623 
    """
1624 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1625 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1626 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1627 
 
3427 chandransh 1628 
    Parameters:
1629 
     - fromShippingDate
1630 
     - toShippingDate
1631 
     - providerId
1632 
     - warehouseId
3451 chandransh 1633 
     - cod
3427 chandransh 1634 
    """
3451 chandransh 1635 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1636 
    return self.recv_getOrdersByShippingDate()
1637 
 
3451 chandransh 1638 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1639 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1640 
    args = getOrdersByShippingDate_args()
1641 
    args.fromShippingDate = fromShippingDate
1642 
    args.toShippingDate = toShippingDate
1643 
    args.providerId = providerId
1644 
    args.warehouseId = warehouseId
3451 chandransh 1645 
    args.cod = cod
3427 chandransh 1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_getOrdersByShippingDate(self, ):
1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
1657 
    result = getOrdersByShippingDate_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
3431 rajveer 1660 
    if result.success is not None:
3427 chandransh 1661 
      return result.success
3431 rajveer 1662 
    if result.ex is not None:
3427 chandransh 1663 
      raise result.ex
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1665 
 
1382 varun.gupt 1666 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1667 
    """
1668 
    Returns order ids for orders which can be returned
3431 rajveer 1669 
 
1382 varun.gupt 1670 
    Parameters:
1671 
     - customer_id
1672 
     - limit
1673 
    """
1674 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1675 
    return self.recv_getReturnableOrdersForCustomer()
1676 
 
1677 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1678 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1679 
    args = getReturnableOrdersForCustomer_args()
1680 
    args.customer_id = customer_id
1681 
    args.limit = limit
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_getReturnableOrdersForCustomer(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = getReturnableOrdersForCustomer_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
3431 rajveer 1696 
    if result.success is not None:
1382 varun.gupt 1697 
      return result.success
3431 rajveer 1698 
    if result.ex is not None:
1382 varun.gupt 1699 
      raise result.ex
1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1701 
 
1702 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1703 
    """
1704 
    Returns order ids for orders which can be cancelled
3431 rajveer 1705 
 
1382 varun.gupt 1706 
    Parameters:
1707 
     - customer_id
1708 
     - limit
1709 
    """
1710 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1711 
    return self.recv_getCancellableOrdersForCustomer()
1712 
 
1713 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1714 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1715 
    args = getCancellableOrdersForCustomer_args()
1716 
    args.customer_id = customer_id
1717 
    args.limit = limit
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getCancellableOrdersForCustomer(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getCancellableOrdersForCustomer_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
3431 rajveer 1732 
    if result.success is not None:
1382 varun.gupt 1733 
      return result.success
3431 rajveer 1734 
    if result.ex is not None:
1382 varun.gupt 1735 
      raise result.ex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1737 
 
483 rajveer 1738 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1739 
    """
1740 
    Parameters:
483 rajveer 1741 
     - orderId
1742 
     - status
1743 
     - description
94 ashish 1744 
    """
483 rajveer 1745 
    self.send_changeOrderStatus(orderId, status, description)
1746 
    return self.recv_changeOrderStatus()
94 ashish 1747 
 
483 rajveer 1748 
  def send_changeOrderStatus(self, orderId, status, description):
1749 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1750 
    args = changeOrderStatus_args()
1751 
    args.orderId = orderId
1752 
    args.status = status
1753 
    args.description = description
94 ashish 1754 
    args.write(self._oprot)
1755 
    self._oprot.writeMessageEnd()
1756 
    self._oprot.trans.flush()
1757 
 
483 rajveer 1758 
  def recv_changeOrderStatus(self, ):
94 ashish 1759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1760 
    if mtype == TMessageType.EXCEPTION:
1761 
      x = TApplicationException()
1762 
      x.read(self._iprot)
1763 
      self._iprot.readMessageEnd()
1764 
      raise x
483 rajveer 1765 
    result = changeOrderStatus_result()
94 ashish 1766 
    result.read(self._iprot)
1767 
    self._iprot.readMessageEnd()
3431 rajveer 1768 
    if result.success is not None:
94 ashish 1769 
      return result.success
3431 rajveer 1770 
    if result.ex is not None:
94 ashish 1771 
      raise result.ex
483 rajveer 1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1773 
 
1528 ankur.sing 1774 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1775 
    """
1528 ankur.sing 1776 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1777 
    only user who owns the transaction can view its order details.
3431 rajveer 1778 
 
94 ashish 1779 
    Parameters:
1780 
     - transactionId
1528 ankur.sing 1781 
     - customerId
94 ashish 1782 
    """
1528 ankur.sing 1783 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1784 
    return self.recv_getOrdersForTransaction()
94 ashish 1785 
 
1528 ankur.sing 1786 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1787 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1788 
    args = getOrdersForTransaction_args()
94 ashish 1789 
    args.transactionId = transactionId
1528 ankur.sing 1790 
    args.customerId = customerId
94 ashish 1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
483 rajveer 1795 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
483 rajveer 1802 
    result = getOrdersForTransaction_result()
94 ashish 1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
94 ashish 1806 
      return result.success
3431 rajveer 1807 
    if result.ex is not None:
94 ashish 1808 
      raise result.ex
483 rajveer 1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1810 
 
3014 chandransh 1811 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1812 
    """
3014 chandransh 1813 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1814 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1815 
 
94 ashish 1816 
    Parameters:
483 rajveer 1817 
     - customerId
1818 
     - from_date
1819 
     - to_date
3014 chandransh 1820 
     - statuses
94 ashish 1821 
    """
3014 chandransh 1822 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1823 
    return self.recv_getOrdersForCustomer()
94 ashish 1824 
 
3014 chandransh 1825 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1826 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1827 
    args = getOrdersForCustomer_args()
1828 
    args.customerId = customerId
1829 
    args.from_date = from_date
1830 
    args.to_date = to_date
3014 chandransh 1831 
    args.statuses = statuses
94 ashish 1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
483 rajveer 1836 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
483 rajveer 1843 
    result = getOrdersForCustomer_result()
94 ashish 1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
3431 rajveer 1846 
    if result.success is not None:
94 ashish 1847 
      return result.success
3431 rajveer 1848 
    if result.ex is not None:
94 ashish 1849 
      raise result.ex
483 rajveer 1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1851 
 
483 rajveer 1852 
  def createOrder(self, order):
94 ashish 1853 
    """
1854 
    Parameters:
483 rajveer 1855 
     - order
94 ashish 1856 
    """
483 rajveer 1857 
    self.send_createOrder(order)
1858 
    return self.recv_createOrder()
94 ashish 1859 
 
483 rajveer 1860 
  def send_createOrder(self, order):
1861 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1862 
    args = createOrder_args()
1863 
    args.order = order
94 ashish 1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
483 rajveer 1868 
  def recv_createOrder(self, ):
94 ashish 1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
483 rajveer 1875 
    result = createOrder_result()
94 ashish 1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
3431 rajveer 1878 
    if result.success is not None:
94 ashish 1879 
      return result.success
3431 rajveer 1880 
    if result.ex is not None:
94 ashish 1881 
      raise result.ex
483 rajveer 1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1883 
 
483 rajveer 1884 
  def getOrder(self, id):
94 ashish 1885 
    """
1886 
    Parameters:
483 rajveer 1887 
     - id
94 ashish 1888 
    """
483 rajveer 1889 
    self.send_getOrder(id)
1890 
    return self.recv_getOrder()
94 ashish 1891 
 
483 rajveer 1892 
  def send_getOrder(self, id):
1893 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1894 
    args = getOrder_args()
1895 
    args.id = id
94 ashish 1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
483 rajveer 1900 
  def recv_getOrder(self, ):
94 ashish 1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
483 rajveer 1907 
    result = getOrder_result()
94 ashish 1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
3431 rajveer 1910 
    if result.success is not None:
94 ashish 1911 
      return result.success
3431 rajveer 1912 
    if result.ex is not None:
94 ashish 1913 
      raise result.ex
483 rajveer 1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1915 
 
483 rajveer 1916 
  def getLineItemsForOrder(self, orderId):
94 ashish 1917 
    """
1918 
    Parameters:
483 rajveer 1919 
     - orderId
94 ashish 1920 
    """
483 rajveer 1921 
    self.send_getLineItemsForOrder(orderId)
1922 
    return self.recv_getLineItemsForOrder()
94 ashish 1923 
 
483 rajveer 1924 
  def send_getLineItemsForOrder(self, orderId):
1925 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1926 
    args = getLineItemsForOrder_args()
1927 
    args.orderId = orderId
94 ashish 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
483 rajveer 1932 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
483 rajveer 1939 
    result = getLineItemsForOrder_result()
94 ashish 1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
3431 rajveer 1942 
    if result.success is not None:
94 ashish 1943 
      return result.success
3431 rajveer 1944 
    if result.ex is not None:
94 ashish 1945 
      raise result.ex
483 rajveer 1946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1947 
 
4999 phani.kuma 1948 
  def getOrderList(self, order_ids):
1949 
    """
1950 
    Parameters:
1951 
     - order_ids
1952 
    """
1953 
    self.send_getOrderList(order_ids)
1954 
    return self.recv_getOrderList()
1955 
 
1956 
  def send_getOrderList(self, order_ids):
1957 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1958 
    args = getOrderList_args()
1959 
    args.order_ids = order_ids
1960 
    args.write(self._oprot)
1961 
    self._oprot.writeMessageEnd()
1962 
    self._oprot.trans.flush()
1963 
 
1964 
  def recv_getOrderList(self, ):
1965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1966 
    if mtype == TMessageType.EXCEPTION:
1967 
      x = TApplicationException()
1968 
      x.read(self._iprot)
1969 
      self._iprot.readMessageEnd()
1970 
      raise x
1971 
    result = getOrderList_result()
1972 
    result.read(self._iprot)
1973 
    self._iprot.readMessageEnd()
1974 
    if result.success is not None:
1975 
      return result.success
1976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1977 
 
5386 phani.kuma 1978 
  def getOrderListForVendor(self, order_ids, vendorId):
1979 
    """
1980 
    Parameters:
1981 
     - order_ids
1982 
     - vendorId
1983 
    """
1984 
    self.send_getOrderListForVendor(order_ids, vendorId)
1985 
    return self.recv_getOrderListForVendor()
1986 
 
1987 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1988 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1989 
    args = getOrderListForVendor_args()
1990 
    args.order_ids = order_ids
1991 
    args.vendorId = vendorId
1992 
    args.write(self._oprot)
1993 
    self._oprot.writeMessageEnd()
1994 
    self._oprot.trans.flush()
1995 
 
1996 
  def recv_getOrderListForVendor(self, ):
1997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1998 
    if mtype == TMessageType.EXCEPTION:
1999 
      x = TApplicationException()
2000 
      x.read(self._iprot)
2001 
      self._iprot.readMessageEnd()
2002 
      raise x
2003 
    result = getOrderListForVendor_result()
2004 
    result.read(self._iprot)
2005 
    self._iprot.readMessageEnd()
2006 
    if result.success is not None:
2007 
      return result.success
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2009 
 
1528 ankur.sing 2010 
  def getOrderForCustomer(self, orderId, customerId):
2011 
    """
2012 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2013 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2014 
 
1528 ankur.sing 2015 
    Parameters:
2016 
     - orderId
2017 
     - customerId
2018 
    """
2019 
    self.send_getOrderForCustomer(orderId, customerId)
2020 
    return self.recv_getOrderForCustomer()
2021 
 
2022 
  def send_getOrderForCustomer(self, orderId, customerId):
2023 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2024 
    args = getOrderForCustomer_args()
2025 
    args.orderId = orderId
2026 
    args.customerId = customerId
2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
2031 
  def recv_getOrderForCustomer(self, ):
2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
2038 
    result = getOrderForCustomer_result()
2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
1528 ankur.sing 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
1528 ankur.sing 2044 
      raise result.ex
2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2046 
 
4444 rajveer 2047 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2048 
    """
2049 
    Parameters:
4394 rajveer 2050 
     - type
4444 rajveer 2051 
     - warehouseId
4394 rajveer 2052 
     - status
2053 
     - timestamp
3064 chandransh 2054 
    """
4444 rajveer 2055 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2056 
    return self.recv_getAlerts()
2057 
 
4444 rajveer 2058 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2059 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2060 
    args = getAlerts_args()
4394 rajveer 2061 
    args.type = type
4444 rajveer 2062 
    args.warehouseId = warehouseId
4394 rajveer 2063 
    args.status = status
2064 
    args.timestamp = timestamp
3064 chandransh 2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getAlerts(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getAlerts_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
3431 rajveer 2079 
    if result.success is not None:
3064 chandransh 2080 
      return result.success
2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2082 
 
4444 rajveer 2083 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2084 
    """
2085 
    Parameters:
2086 
     - type
4444 rajveer 2087 
     - warehouseId
4394 rajveer 2088 
     - description
3064 chandransh 2089 
    """
4444 rajveer 2090 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2091 
    self.recv_addAlert()
3064 chandransh 2092 
 
4444 rajveer 2093 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2094 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2095 
    args = addAlert_args()
3064 chandransh 2096 
    args.type = type
4444 rajveer 2097 
    args.warehouseId = warehouseId
4394 rajveer 2098 
    args.description = description
3064 chandransh 2099 
    args.write(self._oprot)
2100 
    self._oprot.writeMessageEnd()
2101 
    self._oprot.trans.flush()
2102 
 
4394 rajveer 2103 
  def recv_addAlert(self, ):
3064 chandransh 2104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2105 
    if mtype == TMessageType.EXCEPTION:
2106 
      x = TApplicationException()
2107 
      x.read(self._iprot)
2108 
      self._iprot.readMessageEnd()
2109 
      raise x
4394 rajveer 2110 
    result = addAlert_result()
3064 chandransh 2111 
    result.read(self._iprot)
2112 
    self._iprot.readMessageEnd()
2113 
    return
2114 
 
4444 rajveer 2115 
  def markAlertsAsSeen(self, warehouseId):
2116 
    """
2117 
    Parameters:
2118 
     - warehouseId
2119 
    """
2120 
    self.send_markAlertsAsSeen(warehouseId)
2121 
    self.recv_markAlertsAsSeen()
2122 
 
2123 
  def send_markAlertsAsSeen(self, warehouseId):
2124 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2125 
    args = markAlertsAsSeen_args()
2126 
    args.warehouseId = warehouseId
2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
2131 
  def recv_markAlertsAsSeen(self, ):
2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
2138 
    result = markAlertsAsSeen_result()
2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
2141 
    return
2142 
 
3064 chandransh 2143 
  def getValidOrderCount(self, ):
2144 
    """
2145 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2146 
    """
2147 
    self.send_getValidOrderCount()
2148 
    return self.recv_getValidOrderCount()
2149 
 
2150 
  def send_getValidOrderCount(self, ):
2151 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2152 
    args = getValidOrderCount_args()
2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_getValidOrderCount(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 = getValidOrderCount_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, "getValidOrderCount failed: unknown result");
2170 
 
2171 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2172 
    """
2173 
    Returns the number of distinct customers who have done successful transactions
2174 
    """
2175 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2176 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2177 
 
2178 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2179 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2180 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
3431 rajveer 2195 
    if result.success is not None:
3064 chandransh 2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2198 
 
2199 
  def getValidOrdersAmountRange(self, ):
2200 
    """
2201 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2202 
    List contains two values, first minimum amount and second maximum amount.
2203 
    """
2204 
    self.send_getValidOrdersAmountRange()
2205 
    return self.recv_getValidOrdersAmountRange()
2206 
 
2207 
  def send_getValidOrdersAmountRange(self, ):
2208 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2209 
    args = getValidOrdersAmountRange_args()
2210 
    args.write(self._oprot)
2211 
    self._oprot.writeMessageEnd()
2212 
    self._oprot.trans.flush()
2213 
 
2214 
  def recv_getValidOrdersAmountRange(self, ):
2215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2216 
    if mtype == TMessageType.EXCEPTION:
2217 
      x = TApplicationException()
2218 
      x.read(self._iprot)
2219 
      self._iprot.readMessageEnd()
2220 
      raise x
2221 
    result = getValidOrdersAmountRange_result()
2222 
    result.read(self._iprot)
2223 
    self._iprot.readMessageEnd()
3431 rajveer 2224 
    if result.success is not None:
3064 chandransh 2225 
      return result.success
2226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2227 
 
2228 
  def getValidOrders(self, limit):
2229 
    """
2230 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2231 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2232 
 
3064 chandransh 2233 
    Parameters:
2234 
     - limit
2235 
    """
2236 
    self.send_getValidOrders(limit)
2237 
    return self.recv_getValidOrders()
2238 
 
2239 
  def send_getValidOrders(self, limit):
2240 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2241 
    args = getValidOrders_args()
2242 
    args.limit = limit
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
2247 
  def recv_getValidOrders(self, ):
2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
2254 
    result = getValidOrders_result()
2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
3431 rajveer 2257 
    if result.success is not None:
3064 chandransh 2258 
      return result.success
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2260 
 
1220 chandransh 2261 
  def batchOrders(self, warehouseId):
2262 
    """
2263 
    Create a batch of all the pending orders for the given warehouse.
2264 
    The returned list is orderd by created_timestamp.
2265 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2266 
 
1220 chandransh 2267 
    Parameters:
2268 
     - warehouseId
2269 
    """
2270 
    self.send_batchOrders(warehouseId)
2271 
    return self.recv_batchOrders()
2272 
 
2273 
  def send_batchOrders(self, warehouseId):
2274 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2275 
    args = batchOrders_args()
2276 
    args.warehouseId = warehouseId
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_batchOrders(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = batchOrders_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
3431 rajveer 2291 
    if result.success is not None:
1220 chandransh 2292 
      return result.success
3431 rajveer 2293 
    if result.ex is not None:
1220 chandransh 2294 
      raise result.ex
2295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2296 
 
1208 chandransh 2297 
  def markOrderAsOutOfStock(self, orderId):
2298 
    """
2299 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2300 
 
1208 chandransh 2301 
    Parameters:
2302 
     - orderId
2303 
    """
2304 
    self.send_markOrderAsOutOfStock(orderId)
2305 
    return self.recv_markOrderAsOutOfStock()
2306 
 
2307 
  def send_markOrderAsOutOfStock(self, orderId):
2308 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2309 
    args = markOrderAsOutOfStock_args()
2310 
    args.orderId = orderId
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2315 
  def recv_markOrderAsOutOfStock(self, ):
2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2322 
    result = markOrderAsOutOfStock_result()
2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.success is not None:
1208 chandransh 2326 
      return result.success
3431 rajveer 2327 
    if result.ex is not None:
1208 chandransh 2328 
      raise result.ex
2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2330 
 
3064 chandransh 2331 
  def verifyOrder(self, orderId):
759 chandransh 2332 
    """
3064 chandransh 2333 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2334 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2335 
    used for all other orders as well.
2336 
    Throws an exception if no such order exists.
3431 rajveer 2337 
 
759 chandransh 2338 
    Parameters:
3064 chandransh 2339 
     - orderId
759 chandransh 2340 
    """
3064 chandransh 2341 
    self.send_verifyOrder(orderId)
2342 
    return self.recv_verifyOrder()
759 chandransh 2343 
 
3064 chandransh 2344 
  def send_verifyOrder(self, orderId):
2345 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2346 
    args = verifyOrder_args()
2347 
    args.orderId = orderId
759 chandransh 2348 
    args.write(self._oprot)
2349 
    self._oprot.writeMessageEnd()
2350 
    self._oprot.trans.flush()
2351 
 
3064 chandransh 2352 
  def recv_verifyOrder(self, ):
759 chandransh 2353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2354 
    if mtype == TMessageType.EXCEPTION:
2355 
      x = TApplicationException()
2356 
      x.read(self._iprot)
2357 
      self._iprot.readMessageEnd()
2358 
      raise x
3064 chandransh 2359 
    result = verifyOrder_result()
759 chandransh 2360 
    result.read(self._iprot)
2361 
    self._iprot.readMessageEnd()
3431 rajveer 2362 
    if result.success is not None:
759 chandransh 2363 
      return result.success
3431 rajveer 2364 
    if result.ex is not None:
759 chandransh 2365 
      raise result.ex
3064 chandransh 2366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2367 
 
3064 chandransh 2368 
  def acceptOrder(self, orderId):
1113 chandransh 2369 
    """
3064 chandransh 2370 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2371 
    given order is not a COD order, it also captures the payment if the same has
2372 
    not been captured.
2373 
    Throws an exception if no such order exists.
3431 rajveer 2374 
 
1113 chandransh 2375 
    Parameters:
3064 chandransh 2376 
     - orderId
1113 chandransh 2377 
    """
3064 chandransh 2378 
    self.send_acceptOrder(orderId)
2379 
    return self.recv_acceptOrder()
1113 chandransh 2380 
 
3064 chandransh 2381 
  def send_acceptOrder(self, orderId):
2382 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2383 
    args = acceptOrder_args()
2384 
    args.orderId = orderId
1113 chandransh 2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
3064 chandransh 2389 
  def recv_acceptOrder(self, ):
1113 chandransh 2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
3064 chandransh 2396 
    result = acceptOrder_result()
1113 chandransh 2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
3431 rajveer 2399 
    if result.success is not None:
1113 chandransh 2400 
      return result.success
3431 rajveer 2401 
    if result.ex is not None:
1113 chandransh 2402 
      raise result.ex
3064 chandransh 2403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2404 
 
5110 mandeep.dh 2405 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2406 
    """
3064 chandransh 2407 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2408 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2409 
    the IMEI no. if a -1 is supplied.
2410 
    Also, it generates an invoice number for the order, marks the order as
2411 
    BILLED and sets the billing timestamp.
2412 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2413 
 
1135 chandransh 2414 
    Parameters:
3064 chandransh 2415 
     - orderId
2416 
     - invoice_number
4658 mandeep.dh 2417 
     - serialNumber
4283 anupam.sin 2418 
     - itemNumber
3064 chandransh 2419 
     - billed_by
4264 rajveer 2420 
     - jacketNumber
4283 anupam.sin 2421 
     - billingType
5110 mandeep.dh 2422 
     - fulfilmentWarehouseId
4763 rajveer 2423 
     - authorize
1135 chandransh 2424 
    """
5110 mandeep.dh 2425 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2426 
    return self.recv_addBillingDetails()
1135 chandransh 2427 
 
5110 mandeep.dh 2428 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2429 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2430 
    args = addBillingDetails_args()
2431 
    args.orderId = orderId
2432 
    args.invoice_number = invoice_number
4658 mandeep.dh 2433 
    args.serialNumber = serialNumber
4283 anupam.sin 2434 
    args.itemNumber = itemNumber
3064 chandransh 2435 
    args.billed_by = billed_by
4264 rajveer 2436 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2437 
    args.billingType = billingType
5110 mandeep.dh 2438 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2439 
    args.authorize = authorize
1135 chandransh 2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
3064 chandransh 2444 
  def recv_addBillingDetails(self, ):
1135 chandransh 2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
3064 chandransh 2451 
    result = addBillingDetails_result()
1135 chandransh 2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
3431 rajveer 2454 
    if result.success is not None:
3064 chandransh 2455 
      return result.success
3431 rajveer 2456 
    if result.ex is not None:
1135 chandransh 2457 
      raise result.ex
3064 chandransh 2458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2459 
 
4763 rajveer 2460 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2461 
    """
2462 
    Add the invoice number to the order.
2463 
 
2464 
    Parameters:
2465 
     - orderId
2466 
     - invoiceNumber
4763 rajveer 2467 
     - color
4579 rajveer 2468 
    """
4763 rajveer 2469 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2470 
    self.recv_addInvoiceNumber()
2471 
 
4763 rajveer 2472 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2473 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2474 
    args = addInvoiceNumber_args()
2475 
    args.orderId = orderId
2476 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2477 
    args.color = color
4579 rajveer 2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
2482 
  def recv_addInvoiceNumber(self, ):
2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
2489 
    result = addInvoiceNumber_result()
2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
2492 
    if result.ex is not None:
2493 
      raise result.ex
2494 
    return
2495 
 
4910 phani.kuma 2496 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2497 
    """
3064 chandransh 2498 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2499 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2500 
 
1408 ankur.sing 2501 
    Parameters:
3064 chandransh 2502 
     - warehouseId
1408 ankur.sing 2503 
     - providerId
3064 chandransh 2504 
     - cod
4910 phani.kuma 2505 
     - orderIds
1408 ankur.sing 2506 
    """
4910 phani.kuma 2507 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2508 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2509 
 
4910 phani.kuma 2510 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2511 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2512 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2513 
    args.warehouseId = warehouseId
1408 ankur.sing 2514 
    args.providerId = providerId
3064 chandransh 2515 
    args.cod = cod
4910 phani.kuma 2516 
    args.orderIds = orderIds
1408 ankur.sing 2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
4910 phani.kuma 2521 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
4910 phani.kuma 2528 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
3431 rajveer 2531 
    if result.success is not None:
1408 ankur.sing 2532 
      return result.success
3431 rajveer 2533 
    if result.ex is not None:
3064 chandransh 2534 
      raise result.ex
4910 phani.kuma 2535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2536 
 
4910 phani.kuma 2537 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2538 
    """
4910 phani.kuma 2539 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2540 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2541 
 
2542 
    Parameters:
2543 
     - providerId
4910 phani.kuma 2544 
     - pickupDetails
4410 rajveer 2545 
    """
4910 phani.kuma 2546 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2547 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2548 
 
4910 phani.kuma 2549 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2550 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2551 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2552 
    args.providerId = providerId
4910 phani.kuma 2553 
    args.pickupDetails = pickupDetails
4410 rajveer 2554 
    args.write(self._oprot)
2555 
    self._oprot.writeMessageEnd()
2556 
    self._oprot.trans.flush()
2557 
 
4910 phani.kuma 2558 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2560 
    if mtype == TMessageType.EXCEPTION:
2561 
      x = TApplicationException()
2562 
      x.read(self._iprot)
2563 
      self._iprot.readMessageEnd()
2564 
      raise x
4910 phani.kuma 2565 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2566 
    result.read(self._iprot)
2567 
    self._iprot.readMessageEnd()
2568 
    if result.ex is not None:
2569 
      raise result.ex
4910 phani.kuma 2570 
    return
4410 rajveer 2571 
 
4910 phani.kuma 2572 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2573 
    """
3064 chandransh 2574 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2575 
 
94 ashish 2576 
    Parameters:
3064 chandransh 2577 
     - providerId
304 ashish 2578 
    """
4910 phani.kuma 2579 
    self.send_getOrdersNotPickedUp(providerId)
2580 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2581 
 
4910 phani.kuma 2582 
  def send_getOrdersNotPickedUp(self, providerId):
2583 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2584 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2585 
    args.providerId = providerId
304 ashish 2586 
    args.write(self._oprot)
2587 
    self._oprot.writeMessageEnd()
2588 
    self._oprot.trans.flush()
2589 
 
4910 phani.kuma 2590 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2592 
    if mtype == TMessageType.EXCEPTION:
2593 
      x = TApplicationException()
2594 
      x.read(self._iprot)
2595 
      self._iprot.readMessageEnd()
2596 
      raise x
4910 phani.kuma 2597 
    result = getOrdersNotPickedUp_result()
304 ashish 2598 
    result.read(self._iprot)
2599 
    self._iprot.readMessageEnd()
3431 rajveer 2600 
    if result.success is not None:
304 ashish 2601 
      return result.success
4910 phani.kuma 2602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2603 
 
3064 chandransh 2604 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2605 
    """
3064 chandransh 2606 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2607 
    the name of the receiver.
2608 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2609 
 
304 ashish 2610 
    Parameters:
3064 chandransh 2611 
     - providerId
2612 
     - deliveredOrders
304 ashish 2613 
    """
3064 chandransh 2614 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2615 
    self.recv_markOrdersAsDelivered()
304 ashish 2616 
 
3064 chandransh 2617 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2618 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2619 
    args = markOrdersAsDelivered_args()
2620 
    args.providerId = providerId
2621 
    args.deliveredOrders = deliveredOrders
304 ashish 2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
3064 chandransh 2626 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
3064 chandransh 2633 
    result = markOrdersAsDelivered_result()
304 ashish 2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
3431 rajveer 2636 
    if result.ex is not None:
3064 chandransh 2637 
      raise result.ex
304 ashish 2638 
    return
2639 
 
4910 phani.kuma 2640 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2641 
    """
4910 phani.kuma 2642 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2643 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2644 
 
3064 chandransh 2645 
    Parameters:
2646 
     - providerId
2647 
     - returnedOrders
1596 ankur.sing 2648 
    """
4910 phani.kuma 2649 
    self.send_markAsRTOrders(providerId, returnedOrders)
2650 
    self.recv_markAsRTOrders()
304 ashish 2651 
 
4910 phani.kuma 2652 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2653 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2654 
    args = markAsRTOrders_args()
3064 chandransh 2655 
    args.providerId = providerId
2656 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
4910 phani.kuma 2661 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2663 
    if mtype == TMessageType.EXCEPTION:
2664 
      x = TApplicationException()
2665 
      x.read(self._iprot)
2666 
      self._iprot.readMessageEnd()
2667 
      raise x
4910 phani.kuma 2668 
    result = markAsRTOrders_result()
1596 ankur.sing 2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
3431 rajveer 2671 
    if result.ex is not None:
3064 chandransh 2672 
      raise result.ex
2673 
    return
1596 ankur.sing 2674 
 
4910 phani.kuma 2675 
  def getRTOrders(self, providerId):
2676 
    """
2677 
    Returns a list of orders that were returned by courier.
2678 
 
2679 
    Parameters:
2680 
     - providerId
2681 
    """
2682 
    self.send_getRTOrders(providerId)
2683 
    return self.recv_getRTOrders()
2684 
 
2685 
  def send_getRTOrders(self, providerId):
2686 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2687 
    args = getRTOrders_args()
2688 
    args.providerId = providerId
2689 
    args.write(self._oprot)
2690 
    self._oprot.writeMessageEnd()
2691 
    self._oprot.trans.flush()
2692 
 
2693 
  def recv_getRTOrders(self, ):
2694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2695 
    if mtype == TMessageType.EXCEPTION:
2696 
      x = TApplicationException()
2697 
      x.read(self._iprot)
2698 
      self._iprot.readMessageEnd()
2699 
      raise x
2700 
    result = getRTOrders_result()
2701 
    result.read(self._iprot)
2702 
    self._iprot.readMessageEnd()
2703 
    if result.success is not None:
2704 
      return result.success
2705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2706 
 
3064 chandransh 2707 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2708 
    """
3064 chandransh 2709 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2710 
 
3064 chandransh 2711 
    Parameters:
2712 
     - providerId
2713 
     - undeliveredOrders
1627 ankur.sing 2714 
    """
3064 chandransh 2715 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2716 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2717 
 
3064 chandransh 2718 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2719 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2720 
    args = updateNonDeliveryReason_args()
2721 
    args.providerId = providerId
2722 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
3064 chandransh 2727 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
3064 chandransh 2734 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
4910 phani.kuma 2737 
    if result.ex is not None:
2738 
      raise result.ex
2739 
    return
2740 
 
2741 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2742 
    """
2743 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2744 
 
2745 
    Parameters:
2746 
     - providerId
2747 
    """
2748 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2749 
    return self.recv_getNonDeliveredOrdersbyCourier()
2750 
 
2751 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2752 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2753 
    args = getNonDeliveredOrdersbyCourier_args()
2754 
    args.providerId = providerId
2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
2759 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
2766 
    result = getNonDeliveredOrdersbyCourier_result()
2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
4581 phani.kuma 2769 
    if result.success is not None:
2770 
      return result.success
4910 phani.kuma 2771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2772 
 
2773 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2774 
    """
2775 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2776 
 
2777 
    Parameters:
2778 
     - providerId
2779 
     - local_connected_orders
2780 
    """
2781 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2782 
    self.recv_markOrdersAsLocalConnected()
2783 
 
2784 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2785 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2786 
    args = markOrdersAsLocalConnected_args()
2787 
    args.providerId = providerId
2788 
    args.local_connected_orders = local_connected_orders
2789 
    args.write(self._oprot)
2790 
    self._oprot.writeMessageEnd()
2791 
    self._oprot.trans.flush()
2792 
 
2793 
  def recv_markOrdersAsLocalConnected(self, ):
2794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2795 
    if mtype == TMessageType.EXCEPTION:
2796 
      x = TApplicationException()
2797 
      x.read(self._iprot)
2798 
      self._iprot.readMessageEnd()
2799 
      raise x
2800 
    result = markOrdersAsLocalConnected_result()
2801 
    result.read(self._iprot)
2802 
    self._iprot.readMessageEnd()
3431 rajveer 2803 
    if result.ex is not None:
3064 chandransh 2804 
      raise result.ex
4910 phani.kuma 2805 
    return
1627 ankur.sing 2806 
 
4910 phani.kuma 2807 
  def getOrdersNotLocalConnected(self, providerId):
2808 
    """
2809 
    Returns a list of orders that were picked up or shipped but pending local connection.
2810 
 
2811 
    Parameters:
2812 
     - providerId
2813 
    """
2814 
    self.send_getOrdersNotLocalConnected(providerId)
2815 
    return self.recv_getOrdersNotLocalConnected()
2816 
 
2817 
  def send_getOrdersNotLocalConnected(self, providerId):
2818 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2819 
    args = getOrdersNotLocalConnected_args()
2820 
    args.providerId = providerId
2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getOrdersNotLocalConnected(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getOrdersNotLocalConnected_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success is not None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2838 
 
2839 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2840 
    """
2841 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2842 
 
2843 
    Parameters:
2844 
     - providerId
2845 
     - destination_city_reached_orders
2846 
    """
2847 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2848 
    self.recv_markOrdersAsDestinationCityReached()
2849 
 
2850 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2851 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2852 
    args = markOrdersAsDestinationCityReached_args()
2853 
    args.providerId = providerId
2854 
    args.destination_city_reached_orders = destination_city_reached_orders
2855 
    args.write(self._oprot)
2856 
    self._oprot.writeMessageEnd()
2857 
    self._oprot.trans.flush()
2858 
 
2859 
  def recv_markOrdersAsDestinationCityReached(self, ):
2860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2861 
    if mtype == TMessageType.EXCEPTION:
2862 
      x = TApplicationException()
2863 
      x.read(self._iprot)
2864 
      self._iprot.readMessageEnd()
2865 
      raise x
2866 
    result = markOrdersAsDestinationCityReached_result()
2867 
    result.read(self._iprot)
2868 
    self._iprot.readMessageEnd()
2869 
    if result.ex is not None:
2870 
      raise result.ex
2871 
    return
2872 
 
2873 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2874 
    """
2875 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2876 
 
2877 
    Parameters:
2878 
     - providerId
2879 
     - first_atdl_orders
2880 
    """
2881 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2882 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2883 
 
2884 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2885 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2886 
    args = markOrdersAsFirstDeliveryAttempted_args()
2887 
    args.providerId = providerId
2888 
    args.first_atdl_orders = first_atdl_orders
2889 
    args.write(self._oprot)
2890 
    self._oprot.writeMessageEnd()
2891 
    self._oprot.trans.flush()
2892 
 
2893 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2895 
    if mtype == TMessageType.EXCEPTION:
2896 
      x = TApplicationException()
2897 
      x.read(self._iprot)
2898 
      self._iprot.readMessageEnd()
2899 
      raise x
2900 
    result = markOrdersAsFirstDeliveryAttempted_result()
2901 
    result.read(self._iprot)
2902 
    self._iprot.readMessageEnd()
2903 
    if result.ex is not None:
2904 
      raise result.ex
2905 
    return
2906 
 
3064 chandransh 2907 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2908 
    """
3064 chandransh 2909 
    Returns the list of orders whose delivery time has passed but have not been
2910 
    delivered yet for the given provider and warehouse. To get a complete list of
2911 
    undelivered orders, pass them as -1.
2912 
    Returns an empty list if no such orders exist.
3431 rajveer 2913 
 
1886 ankur.sing 2914 
    Parameters:
3064 chandransh 2915 
     - providerId
2916 
     - warehouseId
1886 ankur.sing 2917 
    """
3064 chandransh 2918 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2919 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2920 
 
3064 chandransh 2921 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2922 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2923 
    args = getUndeliveredOrders_args()
2924 
    args.providerId = providerId
2925 
    args.warehouseId = warehouseId
1886 ankur.sing 2926 
    args.write(self._oprot)
2927 
    self._oprot.writeMessageEnd()
2928 
    self._oprot.trans.flush()
2929 
 
3064 chandransh 2930 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2932 
    if mtype == TMessageType.EXCEPTION:
2933 
      x = TApplicationException()
2934 
      x.read(self._iprot)
2935 
      self._iprot.readMessageEnd()
2936 
      raise x
3064 chandransh 2937 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2938 
    result.read(self._iprot)
2939 
    self._iprot.readMessageEnd()
3431 rajveer 2940 
    if result.success is not None:
1886 ankur.sing 2941 
      return result.success
3064 chandransh 2942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2943 
 
4783 phani.kuma 2944 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2945 
    """
2946 
    Returns the list of orders whose expected delivery date has passed but have not been
2947 
    delivered yet.
2948 
    Returns an empty list if no such orders exist.
2949 
    """
2950 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2951 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2952 
 
2953 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2954 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2955 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
2960 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
2967 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
2970 
    if result.success is not None:
2971 
      return result.success
2972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2973 
 
2536 chandransh 2974 
  def toggleDOAFlag(self, orderId):
2975 
    """
2976 
    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.
2977 
    Returns the final flag status.
2978 
    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 2979 
 
2536 chandransh 2980 
    Parameters:
2981 
     - orderId
2982 
    """
2983 
    self.send_toggleDOAFlag(orderId)
2984 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2985 
 
2536 chandransh 2986 
  def send_toggleDOAFlag(self, orderId):
2987 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2988 
    args = toggleDOAFlag_args()
2989 
    args.orderId = orderId
2990 
    args.write(self._oprot)
2991 
    self._oprot.writeMessageEnd()
2992 
    self._oprot.trans.flush()
2993 
 
2994 
  def recv_toggleDOAFlag(self, ):
2995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2996 
    if mtype == TMessageType.EXCEPTION:
2997 
      x = TApplicationException()
2998 
      x.read(self._iprot)
2999 
      self._iprot.readMessageEnd()
3000 
      raise x
3001 
    result = toggleDOAFlag_result()
3002 
    result.read(self._iprot)
3003 
    self._iprot.readMessageEnd()
3431 rajveer 3004 
    if result.success is not None:
2536 chandransh 3005 
      return result.success
3431 rajveer 3006 
    if result.ex is not None:
2536 chandransh 3007 
      raise result.ex
3008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3009 
 
4712 rajveer 3010 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3011 
    """
3012 
    Parameters:
3013 
     - orderId
3014 
     - deliveryTimestamp
3015 
     - receiver
3016 
    """
3017 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3018 
    self.recv_markOrderAsDelivered()
3019 
 
3020 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3021 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3022 
    args = markOrderAsDelivered_args()
3023 
    args.orderId = orderId
3024 
    args.deliveryTimestamp = deliveryTimestamp
3025 
    args.receiver = receiver
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_markOrderAsDelivered(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = markOrderAsDelivered_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3040 
    if result.ex is not None:
3041 
      raise result.ex
3042 
    return
3043 
 
5553 rajveer 3044 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3045 
    """
3046 
    Parameters:
3047 
     - orderId
3048 
     - deliveryTimestamp
3049 
    """
3050 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3051 
    self.recv_markOrderAsReceivedAtStore()
3052 
 
3053 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3054 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3055 
    args = markOrderAsReceivedAtStore_args()
3056 
    args.orderId = orderId
3057 
    args.deliveryTimestamp = deliveryTimestamp
3058 
    args.write(self._oprot)
3059 
    self._oprot.writeMessageEnd()
3060 
    self._oprot.trans.flush()
3061 
 
3062 
  def recv_markOrderAsReceivedAtStore(self, ):
3063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3064 
    if mtype == TMessageType.EXCEPTION:
3065 
      x = TApplicationException()
3066 
      x.read(self._iprot)
3067 
      self._iprot.readMessageEnd()
3068 
      raise x
3069 
    result = markOrderAsReceivedAtStore_result()
3070 
    result.read(self._iprot)
3071 
    self._iprot.readMessageEnd()
3072 
    if result.ex is not None:
3073 
      raise result.ex
3074 
    return
3075 
 
4454 rajveer 3076 
  def markOrderDoaRequestReceived(self, orderId):
3077 
    """
3078 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3079 
 
3080 
    Parameters:
3081 
     - orderId
3082 
    """
3083 
    self.send_markOrderDoaRequestReceived(orderId)
3084 
    return self.recv_markOrderDoaRequestReceived()
3085 
 
3086 
  def send_markOrderDoaRequestReceived(self, orderId):
3087 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3088 
    args = markOrderDoaRequestReceived_args()
3089 
    args.orderId = orderId
3090 
    args.write(self._oprot)
3091 
    self._oprot.writeMessageEnd()
3092 
    self._oprot.trans.flush()
3093 
 
3094 
  def recv_markOrderDoaRequestReceived(self, ):
3095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3096 
    if mtype == TMessageType.EXCEPTION:
3097 
      x = TApplicationException()
3098 
      x.read(self._iprot)
3099 
      self._iprot.readMessageEnd()
3100 
      raise x
3101 
    result = markOrderDoaRequestReceived_result()
3102 
    result.read(self._iprot)
3103 
    self._iprot.readMessageEnd()
3104 
    if result.success is not None:
3105 
      return result.success
3106 
    if result.ex is not None:
3107 
      raise result.ex
3108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3109 
 
3110 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3111 
    """
3112 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3113 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3114 
 
3115 
    Parameters:
3116 
     - orderId
3117 
     - isAuthorized
3118 
    """
3119 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3120 
    return self.recv_markOrderDoaRequestAuthorized()
3121 
 
3122 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3123 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3124 
    args = markOrderDoaRequestAuthorized_args()
3125 
    args.orderId = orderId
3126 
    args.isAuthorized = isAuthorized
3127 
    args.write(self._oprot)
3128 
    self._oprot.writeMessageEnd()
3129 
    self._oprot.trans.flush()
3130 
 
3131 
  def recv_markOrderDoaRequestAuthorized(self, ):
3132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3133 
    if mtype == TMessageType.EXCEPTION:
3134 
      x = TApplicationException()
3135 
      x.read(self._iprot)
3136 
      self._iprot.readMessageEnd()
3137 
      raise x
3138 
    result = markOrderDoaRequestAuthorized_result()
3139 
    result.read(self._iprot)
3140 
    self._iprot.readMessageEnd()
3141 
    if result.success is not None:
3142 
      return result.success
3143 
    if result.ex is not None:
3144 
      raise result.ex
3145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3146 
 
4488 rajveer 3147 
  def markOrderReturnRequestReceived(self, orderId):
3148 
    """
3149 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3150 
 
3151 
    Parameters:
3152 
     - orderId
3153 
    """
3154 
    self.send_markOrderReturnRequestReceived(orderId)
3155 
    return self.recv_markOrderReturnRequestReceived()
3156 
 
3157 
  def send_markOrderReturnRequestReceived(self, orderId):
3158 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3159 
    args = markOrderReturnRequestReceived_args()
3160 
    args.orderId = orderId
3161 
    args.write(self._oprot)
3162 
    self._oprot.writeMessageEnd()
3163 
    self._oprot.trans.flush()
3164 
 
3165 
  def recv_markOrderReturnRequestReceived(self, ):
3166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3167 
    if mtype == TMessageType.EXCEPTION:
3168 
      x = TApplicationException()
3169 
      x.read(self._iprot)
3170 
      self._iprot.readMessageEnd()
3171 
      raise x
3172 
    result = markOrderReturnRequestReceived_result()
3173 
    result.read(self._iprot)
3174 
    self._iprot.readMessageEnd()
3175 
    if result.success is not None:
3176 
      return result.success
3177 
    if result.ex is not None:
3178 
      raise result.ex
3179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3180 
 
3181 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3182 
    """
3183 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3184 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3185 
 
3186 
    Parameters:
3187 
     - orderId
3188 
     - isAuthorized
3189 
    """
3190 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3191 
    return self.recv_markOrderReturnRequestAuthorized()
3192 
 
3193 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3194 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3195 
    args = markOrderReturnRequestAuthorized_args()
3196 
    args.orderId = orderId
3197 
    args.isAuthorized = isAuthorized
3198 
    args.write(self._oprot)
3199 
    self._oprot.writeMessageEnd()
3200 
    self._oprot.trans.flush()
3201 
 
3202 
  def recv_markOrderReturnRequestAuthorized(self, ):
3203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3204 
    if mtype == TMessageType.EXCEPTION:
3205 
      x = TApplicationException()
3206 
      x.read(self._iprot)
3207 
      self._iprot.readMessageEnd()
3208 
      raise x
3209 
    result = markOrderReturnRequestAuthorized_result()
3210 
    result.read(self._iprot)
3211 
    self._iprot.readMessageEnd()
3212 
    if result.success is not None:
3213 
      return result.success
3214 
    if result.ex is not None:
3215 
      raise result.ex
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3217 
 
4579 rajveer 3218 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3219 
    """
3220 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3221 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3222 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3223 
    For any other status, it returns false.
3224 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3225 
 
2536 chandransh 3226 
    Parameters:
3227 
     - orderId
4579 rajveer 3228 
     - providerId
2536 chandransh 3229 
    """
4579 rajveer 3230 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3231 
    return self.recv_requestPickupNumber()
3232 
 
4579 rajveer 3233 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3234 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3235 
    args = requestPickupNumber_args()
3236 
    args.orderId = orderId
4579 rajveer 3237 
    args.providerId = providerId
2536 chandransh 3238 
    args.write(self._oprot)
3239 
    self._oprot.writeMessageEnd()
3240 
    self._oprot.trans.flush()
3241 
 
3242 
  def recv_requestPickupNumber(self, ):
3243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3244 
    if mtype == TMessageType.EXCEPTION:
3245 
      x = TApplicationException()
3246 
      x.read(self._iprot)
3247 
      self._iprot.readMessageEnd()
3248 
      raise x
3249 
    result = requestPickupNumber_result()
3250 
    result.read(self._iprot)
3251 
    self._iprot.readMessageEnd()
3431 rajveer 3252 
    if result.success is not None:
2536 chandransh 3253 
      return result.success
3431 rajveer 3254 
    if result.ex is not None:
2536 chandransh 3255 
      raise result.ex
3256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3257 
 
4602 rajveer 3258 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3259 
    """
4452 rajveer 3260 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3261 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3262 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3263 
    	3. Returns true
2591 chandransh 3264 
    If the order is in any other status, it returns false.
2536 chandransh 3265 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3266 
 
2536 chandransh 3267 
    Parameters:
3268 
     - orderId
3269 
     - pickupNumber
4602 rajveer 3270 
     - providerId
2536 chandransh 3271 
    """
4602 rajveer 3272 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3273 
    return self.recv_authorizePickup()
3274 
 
4602 rajveer 3275 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3276 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3277 
    args = authorizePickup_args()
3278 
    args.orderId = orderId
3279 
    args.pickupNumber = pickupNumber
4602 rajveer 3280 
    args.providerId = providerId
2536 chandransh 3281 
    args.write(self._oprot)
3282 
    self._oprot.writeMessageEnd()
3283 
    self._oprot.trans.flush()
3284 
 
3285 
  def recv_authorizePickup(self, ):
3286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3287 
    if mtype == TMessageType.EXCEPTION:
3288 
      x = TApplicationException()
3289 
      x.read(self._iprot)
3290 
      self._iprot.readMessageEnd()
3291 
      raise x
3292 
    result = authorizePickup_result()
3293 
    result.read(self._iprot)
3294 
    self._iprot.readMessageEnd()
3431 rajveer 3295 
    if result.success is not None:
2536 chandransh 3296 
      return result.success
3431 rajveer 3297 
    if result.ex is not None:
2536 chandransh 3298 
      raise result.ex
3299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3300 
 
2764 chandransh 3301 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3302 
    """
3303 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3304 
 
2764 chandransh 3305 
    Parameters:
3306 
     - providerId
3307 
     - pickupDetails
3308 
    """
3309 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3310 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3311 
 
3312 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3313 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3314 
    args = markDoasAsPickedUp_args()
3315 
    args.providerId = providerId
3316 
    args.pickupDetails = pickupDetails
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_markDoasAsPickedUp(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = markDoasAsPickedUp_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
4910 phani.kuma 3331 
    return
3332 
 
3333 
  def getDoasNotPickedUp(self, providerId):
3334 
    """
3335 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3336 
 
3337 
    Parameters:
3338 
     - providerId
3339 
    """
3340 
    self.send_getDoasNotPickedUp(providerId)
3341 
    return self.recv_getDoasNotPickedUp()
3342 
 
3343 
  def send_getDoasNotPickedUp(self, providerId):
3344 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3345 
    args = getDoasNotPickedUp_args()
3346 
    args.providerId = providerId
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_getDoasNotPickedUp(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = getDoasNotPickedUp_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3431 rajveer 3361 
    if result.success is not None:
2764 chandransh 3362 
      return result.success
4910 phani.kuma 3363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3364 
 
4741 phani.kuma 3365 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3366 
    """
3367 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3368 
 
3369 
    Parameters:
3370 
     - providerId
3371 
     - pickupDetails
3372 
    """
3373 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3374 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3375 
 
3376 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3377 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3378 
    args = markReturnOrdersAsPickedUp_args()
3379 
    args.providerId = providerId
3380 
    args.pickupDetails = pickupDetails
3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_markReturnOrdersAsPickedUp(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = markReturnOrdersAsPickedUp_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
4910 phani.kuma 3395 
    return
3396 
 
3397 
  def getReturnOrdersNotPickedUp(self, providerId):
3398 
    """
3399 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3400 
 
3401 
    Parameters:
3402 
     - providerId
3403 
    """
3404 
    self.send_getReturnOrdersNotPickedUp(providerId)
3405 
    return self.recv_getReturnOrdersNotPickedUp()
3406 
 
3407 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3408 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3409 
    args = getReturnOrdersNotPickedUp_args()
3410 
    args.providerId = providerId
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_getReturnOrdersNotPickedUp(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = getReturnOrdersNotPickedUp_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
4741 phani.kuma 3425 
    if result.success is not None:
3426 
      return result.success
4910 phani.kuma 3427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3428 
 
4479 rajveer 3429 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3430 
    """
4452 rajveer 3431 
    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 3432 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3433 
    If the order is in any other state, it returns false.
3434 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3435 
 
2591 chandransh 3436 
    Parameters:
3437 
     - orderId
4479 rajveer 3438 
     - receiveCondition
2591 chandransh 3439 
    """
4479 rajveer 3440 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3441 
    return self.recv_receiveReturn()
2536 chandransh 3442 
 
4479 rajveer 3443 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3444 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3445 
    args = receiveReturn_args()
2591 chandransh 3446 
    args.orderId = orderId
4479 rajveer 3447 
    args.receiveCondition = receiveCondition
2591 chandransh 3448 
    args.write(self._oprot)
3449 
    self._oprot.writeMessageEnd()
3450 
    self._oprot.trans.flush()
3451 
 
2616 chandransh 3452 
  def recv_receiveReturn(self, ):
2591 chandransh 3453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3454 
    if mtype == TMessageType.EXCEPTION:
3455 
      x = TApplicationException()
3456 
      x.read(self._iprot)
3457 
      self._iprot.readMessageEnd()
3458 
      raise x
2616 chandransh 3459 
    result = receiveReturn_result()
2591 chandransh 3460 
    result.read(self._iprot)
3461 
    self._iprot.readMessageEnd()
3431 rajveer 3462 
    if result.success is not None:
2591 chandransh 3463 
      return result.success
3431 rajveer 3464 
    if result.ex is not None:
2591 chandransh 3465 
      raise result.ex
2616 chandransh 3466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3467 
 
3468 
  def validateDoa(self, orderId, isValid):
3469 
    """
4452 rajveer 3470 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3471 
    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 3472 
    If the order is in any other state, it returns false.
3473 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3474 
 
2591 chandransh 3475 
    Parameters:
3476 
     - orderId
3477 
     - isValid
3478 
    """
3479 
    self.send_validateDoa(orderId, isValid)
3480 
    return self.recv_validateDoa()
3481 
 
3482 
  def send_validateDoa(self, orderId, isValid):
3483 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3484 
    args = validateDoa_args()
3485 
    args.orderId = orderId
3486 
    args.isValid = isValid
3487 
    args.write(self._oprot)
3488 
    self._oprot.writeMessageEnd()
3489 
    self._oprot.trans.flush()
3490 
 
3491 
  def recv_validateDoa(self, ):
3492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3493 
    if mtype == TMessageType.EXCEPTION:
3494 
      x = TApplicationException()
3495 
      x.read(self._iprot)
3496 
      self._iprot.readMessageEnd()
3497 
      raise x
3498 
    result = validateDoa_result()
3499 
    result.read(self._iprot)
3500 
    self._iprot.readMessageEnd()
3431 rajveer 3501 
    if result.success is not None:
2591 chandransh 3502 
      return result.success
3431 rajveer 3503 
    if result.ex is not None:
2591 chandransh 3504 
      raise result.ex
3505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3506 
 
4495 rajveer 3507 
  def validateReturnProduct(self, orderId, isUsable):
3508 
    """
3509 
    Parameters:
3510 
     - orderId
3511 
     - isUsable
3512 
    """
3513 
    self.send_validateReturnProduct(orderId, isUsable)
3514 
    return self.recv_validateReturnProduct()
3515 
 
3516 
  def send_validateReturnProduct(self, orderId, isUsable):
3517 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3518 
    args = validateReturnProduct_args()
3519 
    args.orderId = orderId
3520 
    args.isUsable = isUsable
3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_validateReturnProduct(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = validateReturnProduct_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.success is not None:
3536 
      return result.success
3537 
    if result.ex is not None:
3538 
      raise result.ex
3539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3540 
 
2616 chandransh 3541 
  def reshipOrder(self, orderId):
3542 
    """
4484 rajveer 3543 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3544 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3545 
    	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 3546 
 
3547 
    If the order is in DOA_CERT_VALID state, it does the following:
3548 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3549 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3550 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3551 
 
2616 chandransh 3552 
    Returns the id of the newly created order.
3431 rajveer 3553 
 
2616 chandransh 3554 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3555 
 
2616 chandransh 3556 
    Parameters:
3557 
     - orderId
3558 
    """
3559 
    self.send_reshipOrder(orderId)
3560 
    return self.recv_reshipOrder()
2591 chandransh 3561 
 
2616 chandransh 3562 
  def send_reshipOrder(self, orderId):
3563 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3564 
    args = reshipOrder_args()
3565 
    args.orderId = orderId
3566 
    args.write(self._oprot)
3567 
    self._oprot.writeMessageEnd()
3568 
    self._oprot.trans.flush()
3569 
 
3570 
  def recv_reshipOrder(self, ):
3571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3572 
    if mtype == TMessageType.EXCEPTION:
3573 
      x = TApplicationException()
3574 
      x.read(self._iprot)
3575 
      self._iprot.readMessageEnd()
3576 
      raise x
3577 
    result = reshipOrder_result()
3578 
    result.read(self._iprot)
3579 
    self._iprot.readMessageEnd()
3431 rajveer 3580 
    if result.success is not None:
2616 chandransh 3581 
      return result.success
3431 rajveer 3582 
    if result.ex is not None:
2616 chandransh 3583 
      raise result.ex
3584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3585 
 
3226 chandransh 3586 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3587 
    """
4484 rajveer 3588 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3589 
    	1. Creates a refund request for batch processing.
3590 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3591 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3592 
 
2616 chandransh 3593 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3594 
    	1. Creates a refund request for batch processing.
3226 chandransh 3595 
    	2. Cancels the reservation of the item in the warehouse.
3596 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3597 
 
3226 chandransh 3598 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3599 
    	1. Cancels the reservation of the item in the warehouse.
3600 
    	2. Marks the current order as CANCELED.
3601 
 
3602 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3603 
 
2616 chandransh 3604 
    Returns True if it is successful, False otherwise.
3431 rajveer 3605 
 
2616 chandransh 3606 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3607 
 
2616 chandransh 3608 
    Parameters:
3609 
     - orderId
3226 chandransh 3610 
     - refundedBy
3611 
     - reason
2616 chandransh 3612 
    """
3226 chandransh 3613 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3614 
    return self.recv_refundOrder()
3615 
 
3226 chandransh 3616 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3617 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3618 
    args = refundOrder_args()
3619 
    args.orderId = orderId
3226 chandransh 3620 
    args.refundedBy = refundedBy
3621 
    args.reason = reason
2616 chandransh 3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_refundOrder(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = refundOrder_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3431 rajveer 3636 
    if result.success is not None:
2616 chandransh 3637 
      return result.success
3431 rajveer 3638 
    if result.ex is not None:
2616 chandransh 3639 
      raise result.ex
3640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3641 
 
2690 chandransh 3642 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3643 
    """
3644 
    Get all return orders created between the from and to dates for the given warehouse.
3645 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3646 
 
2690 chandransh 3647 
    Parameters:
3648 
     - warehouseId
3649 
     - fromDate
3650 
     - toDate
3651 
    """
3652 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3653 
    return self.recv_getReturnOrders()
2616 chandransh 3654 
 
2690 chandransh 3655 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3656 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3657 
    args = getReturnOrders_args()
3658 
    args.warehouseId = warehouseId
3659 
    args.fromDate = fromDate
3660 
    args.toDate = toDate
3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_getReturnOrders(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = getReturnOrders_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3431 rajveer 3675 
    if result.success is not None:
2690 chandransh 3676 
      return result.success
3677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3678 
 
5481 phani.kuma 3679 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3680 
    """
3681 
    Get all return orders created between the from and to dates.
3682 
 
3683 
    Parameters:
3684 
     - onlyNotProcessed
3685 
     - fromDate
3686 
     - toDate
3687 
    """
3688 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3689 
    return self.recv_getAllReturnOrders()
3690 
 
3691 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3692 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3693 
    args = getAllReturnOrders_args()
3694 
    args.onlyNotProcessed = onlyNotProcessed
3695 
    args.fromDate = fromDate
3696 
    args.toDate = toDate
3697 
    args.write(self._oprot)
3698 
    self._oprot.writeMessageEnd()
3699 
    self._oprot.trans.flush()
3700 
 
3701 
  def recv_getAllReturnOrders(self, ):
3702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3703 
    if mtype == TMessageType.EXCEPTION:
3704 
      x = TApplicationException()
3705 
      x.read(self._iprot)
3706 
      self._iprot.readMessageEnd()
3707 
      raise x
3708 
    result = getAllReturnOrders_result()
3709 
    result.read(self._iprot)
3710 
    self._iprot.readMessageEnd()
3711 
    if result.success is not None:
3712 
      return result.success
3713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3714 
 
2700 chandransh 3715 
  def getReturnOrder(self, id):
3716 
    """
3717 
    Returns the ReturnOrder corresponding to the given id.
3718 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3719 
 
2700 chandransh 3720 
    Parameters:
3721 
     - id
3722 
    """
3723 
    self.send_getReturnOrder(id)
3724 
    return self.recv_getReturnOrder()
3725 
 
3726 
  def send_getReturnOrder(self, id):
3727 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3728 
    args = getReturnOrder_args()
3729 
    args.id = id
3730 
    args.write(self._oprot)
3731 
    self._oprot.writeMessageEnd()
3732 
    self._oprot.trans.flush()
3733 
 
3734 
  def recv_getReturnOrder(self, ):
3735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3736 
    if mtype == TMessageType.EXCEPTION:
3737 
      x = TApplicationException()
3738 
      x.read(self._iprot)
3739 
      self._iprot.readMessageEnd()
3740 
      raise x
3741 
    result = getReturnOrder_result()
3742 
    result.read(self._iprot)
3743 
    self._iprot.readMessageEnd()
3431 rajveer 3744 
    if result.success is not None:
2700 chandransh 3745 
      return result.success
3431 rajveer 3746 
    if result.ex is not None:
2700 chandransh 3747 
      raise result.ex
3748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3749 
 
2690 chandransh 3750 
  def processReturn(self, returnOrderId):
3751 
    """
3752 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3753 
 
2690 chandransh 3754 
    Parameters:
3755 
     - returnOrderId
3756 
    """
3757 
    self.send_processReturn(returnOrderId)
3758 
    self.recv_processReturn()
3759 
 
3760 
  def send_processReturn(self, returnOrderId):
3761 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3762 
    args = processReturn_args()
3763 
    args.returnOrderId = returnOrderId
3764 
    args.write(self._oprot)
3765 
    self._oprot.writeMessageEnd()
3766 
    self._oprot.trans.flush()
3767 
 
3768 
  def recv_processReturn(self, ):
3769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3770 
    if mtype == TMessageType.EXCEPTION:
3771 
      x = TApplicationException()
3772 
      x.read(self._iprot)
3773 
      self._iprot.readMessageEnd()
3774 
      raise x
3775 
    result = processReturn_result()
3776 
    result.read(self._iprot)
3777 
    self._iprot.readMessageEnd()
3431 rajveer 3778 
    if result.ex is not None:
2690 chandransh 3779 
      raise result.ex
3780 
    return
3781 
 
3451 chandransh 3782 
  def updateWeight(self, orderId, weight):
3783 
    """
3784 
    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 3785 
 
3451 chandransh 3786 
    Parameters:
3787 
     - orderId
3788 
     - weight
3789 
    """
3790 
    self.send_updateWeight(orderId, weight)
3791 
    return self.recv_updateWeight()
3792 
 
3793 
  def send_updateWeight(self, orderId, weight):
3794 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3795 
    args = updateWeight_args()
3796 
    args.orderId = orderId
3797 
    args.weight = weight
3798 
    args.write(self._oprot)
3799 
    self._oprot.writeMessageEnd()
3800 
    self._oprot.trans.flush()
3801 
 
3802 
  def recv_updateWeight(self, ):
3803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3804 
    if mtype == TMessageType.EXCEPTION:
3805 
      x = TApplicationException()
3806 
      x.read(self._iprot)
3807 
      self._iprot.readMessageEnd()
3808 
      raise x
3809 
    result = updateWeight_result()
3810 
    result.read(self._iprot)
3811 
    self._iprot.readMessageEnd()
3812 
    if result.success is not None:
3813 
      return result.success
3814 
    if result.ex is not None:
3815 
      raise result.ex
3816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3817 
 
3469 chandransh 3818 
  def changeItem(self, orderId, itemId):
3819 
    """
3820 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3821 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3822 
 
3469 chandransh 3823 
    Parameters:
3824 
     - orderId
3825 
     - itemId
3826 
    """
3827 
    self.send_changeItem(orderId, itemId)
3828 
    return self.recv_changeItem()
3829 
 
3830 
  def send_changeItem(self, orderId, itemId):
3831 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3832 
    args = changeItem_args()
3833 
    args.orderId = orderId
3834 
    args.itemId = itemId
3835 
    args.write(self._oprot)
3836 
    self._oprot.writeMessageEnd()
3837 
    self._oprot.trans.flush()
3838 
 
3839 
  def recv_changeItem(self, ):
3840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3841 
    if mtype == TMessageType.EXCEPTION:
3842 
      x = TApplicationException()
3843 
      x.read(self._iprot)
3844 
      self._iprot.readMessageEnd()
3845 
      raise x
3846 
    result = changeItem_result()
3847 
    result.read(self._iprot)
3848 
    self._iprot.readMessageEnd()
3849 
    if result.success is not None:
3850 
      return result.success
3851 
    if result.ex is not None:
3852 
      raise result.ex
3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3854 
 
3855 
  def shiftToWarehouse(self, orderId, warehouseId):
3856 
    """
3857 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3858 
 
3859 
    Parameters:
3860 
     - orderId
3861 
     - warehouseId
3862 
    """
3863 
    self.send_shiftToWarehouse(orderId, warehouseId)
3864 
    return self.recv_shiftToWarehouse()
3865 
 
3866 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3867 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3868 
    args = shiftToWarehouse_args()
3869 
    args.orderId = orderId
3870 
    args.warehouseId = warehouseId
3871 
    args.write(self._oprot)
3872 
    self._oprot.writeMessageEnd()
3873 
    self._oprot.trans.flush()
3874 
 
3875 
  def recv_shiftToWarehouse(self, ):
3876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3877 
    if mtype == TMessageType.EXCEPTION:
3878 
      x = TApplicationException()
3879 
      x.read(self._iprot)
3880 
      self._iprot.readMessageEnd()
3881 
      raise x
3882 
    result = shiftToWarehouse_result()
3883 
    result.read(self._iprot)
3884 
    self._iprot.readMessageEnd()
3885 
    if result.success is not None:
3886 
      return result.success
3887 
    if result.ex is not None:
3888 
      raise result.ex
3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3890 
 
4647 rajveer 3891 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3892 
    """
3893 
    Adds the given delay reason to the given order.
3986 chandransh 3894 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3895 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3896 
 
3553 chandransh 3897 
    Parameters:
3898 
     - orderId
3899 
     - delayReason
3986 chandransh 3900 
     - furtherDelay
4647 rajveer 3901 
     - delayReasonText
3553 chandransh 3902 
    """
4647 rajveer 3903 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3904 
    return self.recv_addDelayReason()
3905 
 
4647 rajveer 3906 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3907 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3908 
    args = addDelayReason_args()
3909 
    args.orderId = orderId
3910 
    args.delayReason = delayReason
3986 chandransh 3911 
    args.furtherDelay = furtherDelay
4647 rajveer 3912 
    args.delayReasonText = delayReasonText
3553 chandransh 3913 
    args.write(self._oprot)
3914 
    self._oprot.writeMessageEnd()
3915 
    self._oprot.trans.flush()
3916 
 
3917 
  def recv_addDelayReason(self, ):
3918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3919 
    if mtype == TMessageType.EXCEPTION:
3920 
      x = TApplicationException()
3921 
      x.read(self._iprot)
3922 
      self._iprot.readMessageEnd()
3923 
      raise x
3924 
    result = addDelayReason_result()
3925 
    result.read(self._iprot)
3926 
    self._iprot.readMessageEnd()
3927 
    if result.success is not None:
3928 
      return result.success
3929 
    if result.ex is not None:
3930 
      raise result.ex
3931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3932 
 
3956 chandransh 3933 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3934 
    """
3935 
    Marks the COD orders with given AWB nos. as having been processed.
3936 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3937 
 
3956 chandransh 3938 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3939 
    1. There is no order corresponding to an AWB number.
3940 
    2. The captured amount for a payment exceeds the total payment.
3941 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3942 
 
3943 
    Parameters:
3944 
     - collectedAmountMap
3945 
     - xferBy
3946 
     - xferTxnId
3947 
     - xferDate
3948 
    """
3949 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3950 
    return self.recv_reconcileCodCollection()
3951 
 
3952 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3953 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3954 
    args = reconcileCodCollection_args()
3955 
    args.collectedAmountMap = collectedAmountMap
3956 
    args.xferBy = xferBy
3957 
    args.xferTxnId = xferTxnId
3958 
    args.xferDate = xferDate
3959 
    args.write(self._oprot)
3960 
    self._oprot.writeMessageEnd()
3961 
    self._oprot.trans.flush()
3962 
 
3963 
  def recv_reconcileCodCollection(self, ):
3964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3965 
    if mtype == TMessageType.EXCEPTION:
3966 
      x = TApplicationException()
3967 
      x.read(self._iprot)
3968 
      self._iprot.readMessageEnd()
3969 
      raise x
3970 
    result = reconcileCodCollection_result()
3971 
    result.read(self._iprot)
3972 
    self._iprot.readMessageEnd()
3973 
    if result.success is not None:
3974 
      return result.success
3975 
    if result.ex is not None:
3976 
      raise result.ex
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3978 
 
4008 mandeep.dh 3979 
  def getTransactionsRequiringExtraProcessing(self, category):
3980 
    """
4065 mandeep.dh 3981 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3982 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3983 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3984 
 
4008 mandeep.dh 3985 
    Parameters:
3986 
     - category
3987 
    """
3988 
    self.send_getTransactionsRequiringExtraProcessing(category)
3989 
    return self.recv_getTransactionsRequiringExtraProcessing()
3990 
 
3991 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3992 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3993 
    args = getTransactionsRequiringExtraProcessing_args()
3994 
    args.category = category
3995 
    args.write(self._oprot)
3996 
    self._oprot.writeMessageEnd()
3997 
    self._oprot.trans.flush()
3998 
 
3999 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4001 
    if mtype == TMessageType.EXCEPTION:
4002 
      x = TApplicationException()
4003 
      x.read(self._iprot)
4004 
      self._iprot.readMessageEnd()
4005 
      raise x
4006 
    result = getTransactionsRequiringExtraProcessing_result()
4007 
    result.read(self._iprot)
4008 
    self._iprot.readMessageEnd()
4009 
    if result.success is not None:
4010 
      return result.success
4011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4012 
 
4013 
  def markTransactionAsProcessed(self, transactionId, category):
4014 
    """
4015 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4016 
    It essentially deletes the transaction id record for a particular
4017 
    processing type category (if present) from DB.
4018 
    This is currently used by CRM application.
4008 mandeep.dh 4019 
 
4020 
    Parameters:
4021 
     - transactionId
4022 
     - category
4023 
    """
4024 
    self.send_markTransactionAsProcessed(transactionId, category)
4025 
    self.recv_markTransactionAsProcessed()
4026 
 
4027 
  def send_markTransactionAsProcessed(self, transactionId, category):
4028 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4029 
    args = markTransactionAsProcessed_args()
4030 
    args.transactionId = transactionId
4031 
    args.category = category
4032 
    args.write(self._oprot)
4033 
    self._oprot.writeMessageEnd()
4034 
    self._oprot.trans.flush()
4035 
 
4036 
  def recv_markTransactionAsProcessed(self, ):
4037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4038 
    if mtype == TMessageType.EXCEPTION:
4039 
      x = TApplicationException()
4040 
      x.read(self._iprot)
4041 
      self._iprot.readMessageEnd()
4042 
      raise x
4043 
    result = markTransactionAsProcessed_result()
4044 
    result.read(self._iprot)
4045 
    self._iprot.readMessageEnd()
4046 
    return
4047 
 
4018 chandransh 4048 
  def getItemWiseRiskyOrdersCount(self, ):
4049 
    """
4050 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4051 
    is defined as one whose shipping date is about to expire.
4052 
    """
4053 
    self.send_getItemWiseRiskyOrdersCount()
4054 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4055 
 
4018 chandransh 4056 
  def send_getItemWiseRiskyOrdersCount(self, ):
4057 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4058 
    args = getItemWiseRiskyOrdersCount_args()
4059 
    args.write(self._oprot)
4060 
    self._oprot.writeMessageEnd()
4061 
    self._oprot.trans.flush()
4062 
 
4063 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4065 
    if mtype == TMessageType.EXCEPTION:
4066 
      x = TApplicationException()
4067 
      x.read(self._iprot)
4068 
      self._iprot.readMessageEnd()
4069 
      raise x
4070 
    result = getItemWiseRiskyOrdersCount_result()
4071 
    result.read(self._iprot)
4072 
    self._iprot.readMessageEnd()
4073 
    if result.success is not None:
4074 
      return result.success
4075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4076 
 
4295 varun.gupt 4077 
  def getOrdersForItemIds(self, itemIds):
4078 
    """
4079 
    Returns a list of all orders which have items with given id
4080 
 
4081 
    Parameters:
4082 
     - itemIds
4083 
    """
4084 
    self.send_getOrdersForItemIds(itemIds)
4085 
    return self.recv_getOrdersForItemIds()
4086 
 
4087 
  def send_getOrdersForItemIds(self, itemIds):
4088 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4089 
    args = getOrdersForItemIds_args()
4090 
    args.itemIds = itemIds
4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_getOrdersForItemIds(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = getOrdersForItemIds_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
4105 
    if result.success is not None:
4106 
      return result.success
4107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4108 
 
4247 rajveer 4109 
  def markOrderCancellationRequestReceived(self, orderId):
4110 
    """
4111 
    Mark order as cancellation request received. If customer sends request of cancellation of
4112 
    a particular order, this method will be called. It will just change status of the order
4113 
    depending on its current status. It also records the previous status, so that we can move
4114 
    back to that status if cancellation request is denied.
4018 chandransh 4115 
 
4247 rajveer 4116 
    Parameters:
4117 
     - orderId
4118 
    """
4119 
    self.send_markOrderCancellationRequestReceived(orderId)
4120 
    self.recv_markOrderCancellationRequestReceived()
4121 
 
4122 
  def send_markOrderCancellationRequestReceived(self, orderId):
4123 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4124 
    args = markOrderCancellationRequestReceived_args()
4125 
    args.orderId = orderId
4126 
    args.write(self._oprot)
4127 
    self._oprot.writeMessageEnd()
4128 
    self._oprot.trans.flush()
4129 
 
4130 
  def recv_markOrderCancellationRequestReceived(self, ):
4131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4132 
    if mtype == TMessageType.EXCEPTION:
4133 
      x = TApplicationException()
4134 
      x.read(self._iprot)
4135 
      self._iprot.readMessageEnd()
4136 
      raise x
4137 
    result = markOrderCancellationRequestReceived_result()
4138 
    result.read(self._iprot)
4139 
    self._iprot.readMessageEnd()
4140 
    if result.ex is not None:
4141 
      raise result.ex
4142 
    return
4143 
 
4144 
  def markOrderCancellationRequestConfirmed(self, orderId):
4145 
    """
4146 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4147 
    cancellation request confirmed. After this OM will be able to cancel the order.
4148 
 
4149 
    Parameters:
4150 
     - orderId
4151 
    """
4152 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4153 
    self.recv_markOrderCancellationRequestConfirmed()
4154 
 
4155 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4156 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4157 
    args = markOrderCancellationRequestConfirmed_args()
4158 
    args.orderId = orderId
4159 
    args.write(self._oprot)
4160 
    self._oprot.writeMessageEnd()
4161 
    self._oprot.trans.flush()
4162 
 
4163 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4165 
    if mtype == TMessageType.EXCEPTION:
4166 
      x = TApplicationException()
4167 
      x.read(self._iprot)
4168 
      self._iprot.readMessageEnd()
4169 
      raise x
4170 
    result = markOrderCancellationRequestConfirmed_result()
4171 
    result.read(self._iprot)
4172 
    self._iprot.readMessageEnd()
4173 
    if result.ex is not None:
4174 
      raise result.ex
4175 
    return
4176 
 
4177 
  def markOrderCancellationRequestDenied(self, orderId):
4178 
    """
4179 
    If we decide to not to cancel order, we will move the order ro previous status.
4180 
 
4181 
    Parameters:
4182 
     - orderId
4183 
    """
4184 
    self.send_markOrderCancellationRequestDenied(orderId)
4185 
    self.recv_markOrderCancellationRequestDenied()
4186 
 
4187 
  def send_markOrderCancellationRequestDenied(self, orderId):
4188 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4189 
    args = markOrderCancellationRequestDenied_args()
4190 
    args.orderId = orderId
4191 
    args.write(self._oprot)
4192 
    self._oprot.writeMessageEnd()
4193 
    self._oprot.trans.flush()
4194 
 
4195 
  def recv_markOrderCancellationRequestDenied(self, ):
4196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4197 
    if mtype == TMessageType.EXCEPTION:
4198 
      x = TApplicationException()
4199 
      x.read(self._iprot)
4200 
      self._iprot.readMessageEnd()
4201 
      raise x
4202 
    result = markOrderCancellationRequestDenied_result()
4203 
    result.read(self._iprot)
4204 
    self._iprot.readMessageEnd()
4205 
    if result.ex is not None:
4206 
      raise result.ex
4207 
    return
4208 
 
4258 rajveer 4209 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4210 
    """
4258 rajveer 4211 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4212 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4213 
 
4214 
    Parameters:
4258 rajveer 4215 
     - transactionId
4247 rajveer 4216 
    """
4258 rajveer 4217 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4218 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4219 
 
4258 rajveer 4220 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4221 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4222 
    args = markTransactionAsPaymentFlagRemoved_args()
4223 
    args.transactionId = transactionId
4247 rajveer 4224 
    args.write(self._oprot)
4225 
    self._oprot.writeMessageEnd()
4226 
    self._oprot.trans.flush()
4227 
 
4258 rajveer 4228 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4230 
    if mtype == TMessageType.EXCEPTION:
4231 
      x = TApplicationException()
4232 
      x.read(self._iprot)
4233 
      self._iprot.readMessageEnd()
4234 
      raise x
4258 rajveer 4235 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4236 
    result.read(self._iprot)
4237 
    self._iprot.readMessageEnd()
4238 
    if result.ex is not None:
4239 
      raise result.ex
4240 
    return
4241 
 
4259 anupam.sin 4242 
  def refundTransaction(self, transactionId, refundedBy, reason):
4243 
    """
4244 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4245 
    need to be cancelled
4247 rajveer 4246 
 
4259 anupam.sin 4247 
    Parameters:
4248 
     - transactionId
4249 
     - refundedBy
4250 
     - reason
4251 
    """
4252 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4253 
    self.recv_refundTransaction()
4254 
 
4255 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4256 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4257 
    args = refundTransaction_args()
4258 
    args.transactionId = transactionId
4259 
    args.refundedBy = refundedBy
4260 
    args.reason = reason
4261 
    args.write(self._oprot)
4262 
    self._oprot.writeMessageEnd()
4263 
    self._oprot.trans.flush()
4264 
 
4265 
  def recv_refundTransaction(self, ):
4266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4267 
    if mtype == TMessageType.EXCEPTION:
4268 
      x = TApplicationException()
4269 
      x.read(self._iprot)
4270 
      self._iprot.readMessageEnd()
4271 
      raise x
4272 
    result = refundTransaction_result()
4273 
    result.read(self._iprot)
4274 
    self._iprot.readMessageEnd()
4275 
    if result.ex is not None:
4276 
      raise result.ex
4277 
    return
4278 
 
4324 mandeep.dh 4279 
  def updateShipmentAddress(self, orderId, addressId):
4280 
    """
4281 
    Updates shipment address of an order. Delivery and shipping date estimates
4282 
    etc. are also updated here.
4283 
 
4284 
    Throws TransactionServiceException in case address change is not
4285 
    possible due to certain reasons such as new pincode in address is
4286 
    not serviceable etc.
4287 
 
4288 
    Parameters:
4289 
     - orderId
4290 
     - addressId
4291 
    """
4292 
    self.send_updateShipmentAddress(orderId, addressId)
4293 
    self.recv_updateShipmentAddress()
4294 
 
4295 
  def send_updateShipmentAddress(self, orderId, addressId):
4296 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4297 
    args = updateShipmentAddress_args()
4298 
    args.orderId = orderId
4299 
    args.addressId = addressId
4300 
    args.write(self._oprot)
4301 
    self._oprot.writeMessageEnd()
4302 
    self._oprot.trans.flush()
4303 
 
4304 
  def recv_updateShipmentAddress(self, ):
4305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4306 
    if mtype == TMessageType.EXCEPTION:
4307 
      x = TApplicationException()
4308 
      x.read(self._iprot)
4309 
      self._iprot.readMessageEnd()
4310 
      raise x
4311 
    result = updateShipmentAddress_result()
4312 
    result.read(self._iprot)
4313 
    self._iprot.readMessageEnd()
4314 
    if result.ex is not None:
4315 
      raise result.ex
4316 
    return
4317 
 
4285 rajveer 4318 
  def acceptOrdersForItemId(self, itemId, inventory):
4319 
    """
4320 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4321 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4322 
 
4285 rajveer 4323 
    Parameters:
4324 
     - itemId
4325 
     - inventory
4326 
    """
4327 
    self.send_acceptOrdersForItemId(itemId, inventory)
4328 
    return self.recv_acceptOrdersForItemId()
4329 
 
4330 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4331 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4332 
    args = acceptOrdersForItemId_args()
4333 
    args.itemId = itemId
4334 
    args.inventory = inventory
4335 
    args.write(self._oprot)
4336 
    self._oprot.writeMessageEnd()
4337 
    self._oprot.trans.flush()
4338 
 
4339 
  def recv_acceptOrdersForItemId(self, ):
4340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4341 
    if mtype == TMessageType.EXCEPTION:
4342 
      x = TApplicationException()
4343 
      x.read(self._iprot)
4344 
      self._iprot.readMessageEnd()
4345 
      raise x
4346 
    result = acceptOrdersForItemId_result()
4347 
    result.read(self._iprot)
4348 
    self._iprot.readMessageEnd()
4349 
    if result.success is not None:
4350 
      return result.success
4351 
    if result.ex is not None:
4352 
      raise result.ex
4353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4354 
 
4369 rajveer 4355 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4356 
    """
4357 
    Parameters:
4358 
     - vendorId
4359 
     - itemId
4360 
     - quantity
4361 
     - estimate
4369 rajveer 4362 
     - isReminder
4303 rajveer 4363 
    """
4369 rajveer 4364 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4365 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4366 
 
4369 rajveer 4367 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4368 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4369 
    args = markOrdersAsPORaised_args()
4370 
    args.vendorId = vendorId
4371 
    args.itemId = itemId
4372 
    args.quantity = quantity
4373 
    args.estimate = estimate
4369 rajveer 4374 
    args.isReminder = isReminder
4303 rajveer 4375 
    args.write(self._oprot)
4376 
    self._oprot.writeMessageEnd()
4377 
    self._oprot.trans.flush()
4378 
 
4379 
  def recv_markOrdersAsPORaised(self, ):
4380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4381 
    if mtype == TMessageType.EXCEPTION:
4382 
      x = TApplicationException()
4383 
      x.read(self._iprot)
4384 
      self._iprot.readMessageEnd()
4385 
      raise x
4386 
    result = markOrdersAsPORaised_result()
4387 
    result.read(self._iprot)
4388 
    self._iprot.readMessageEnd()
4389 
    if result.ex is not None:
4390 
      raise result.ex
4391 
    return
4392 
 
4369 rajveer 4393 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4394 
    """
4395 
    Parameters:
4396 
     - vendorId
4397 
     - itemId
4398 
     - quantity
4399 
     - estimate
4369 rajveer 4400 
     - isReminder
4303 rajveer 4401 
    """
4369 rajveer 4402 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4403 
    self.recv_markOrdersAsReversalInitiated()
4404 
 
4369 rajveer 4405 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4406 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4407 
    args = markOrdersAsReversalInitiated_args()
4408 
    args.vendorId = vendorId
4409 
    args.itemId = itemId
4410 
    args.quantity = quantity
4411 
    args.estimate = estimate
4369 rajveer 4412 
    args.isReminder = isReminder
4303 rajveer 4413 
    args.write(self._oprot)
4414 
    self._oprot.writeMessageEnd()
4415 
    self._oprot.trans.flush()
4416 
 
4417 
  def recv_markOrdersAsReversalInitiated(self, ):
4418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4419 
    if mtype == TMessageType.EXCEPTION:
4420 
      x = TApplicationException()
4421 
      x.read(self._iprot)
4422 
      self._iprot.readMessageEnd()
4423 
      raise x
4424 
    result = markOrdersAsReversalInitiated_result()
4425 
    result.read(self._iprot)
4426 
    self._iprot.readMessageEnd()
4427 
    if result.ex is not None:
4428 
      raise result.ex
4429 
    return
4430 
 
4369 rajveer 4431 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4432 
    """
4433 
    Parameters:
4434 
     - vendorId
4435 
     - itemId
4436 
     - quantity
4437 
     - estimate
4369 rajveer 4438 
     - isReminder
4303 rajveer 4439 
    """
4369 rajveer 4440 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4441 
    self.recv_markOrdersAsNotAvailabke()
4442 
 
4369 rajveer 4443 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4444 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4445 
    args = markOrdersAsNotAvailabke_args()
4446 
    args.vendorId = vendorId
4447 
    args.itemId = itemId
4448 
    args.quantity = quantity
4449 
    args.estimate = estimate
4369 rajveer 4450 
    args.isReminder = isReminder
4303 rajveer 4451 
    args.write(self._oprot)
4452 
    self._oprot.writeMessageEnd()
4453 
    self._oprot.trans.flush()
4454 
 
4455 
  def recv_markOrdersAsNotAvailabke(self, ):
4456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4457 
    if mtype == TMessageType.EXCEPTION:
4458 
      x = TApplicationException()
4459 
      x.read(self._iprot)
4460 
      self._iprot.readMessageEnd()
4461 
      raise x
4462 
    result = markOrdersAsNotAvailabke_result()
4463 
    result.read(self._iprot)
4464 
    self._iprot.readMessageEnd()
4465 
    if result.ex is not None:
4466 
      raise result.ex
4467 
    return
4468 
 
4369 rajveer 4469 
  def markOrdersAsTimeout(self, vendorId):
4470 
    """
4471 
    Parameters:
4472 
     - vendorId
4473 
    """
4474 
    self.send_markOrdersAsTimeout(vendorId)
4475 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4476 
 
4369 rajveer 4477 
  def send_markOrdersAsTimeout(self, vendorId):
4478 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4479 
    args = markOrdersAsTimeout_args()
4480 
    args.vendorId = vendorId
4481 
    args.write(self._oprot)
4482 
    self._oprot.writeMessageEnd()
4483 
    self._oprot.trans.flush()
4484 
 
4485 
  def recv_markOrdersAsTimeout(self, ):
4486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4487 
    if mtype == TMessageType.EXCEPTION:
4488 
      x = TApplicationException()
4489 
      x.read(self._iprot)
4490 
      self._iprot.readMessageEnd()
4491 
      raise x
4492 
    result = markOrdersAsTimeout_result()
4493 
    result.read(self._iprot)
4494 
    self._iprot.readMessageEnd()
4495 
    if result.success is not None:
4496 
      return result.success
4497 
    if result.ex is not None:
4498 
      raise result.ex
4499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4500 
 
4662 rajveer 4501 
  def markOrderAsLostInTransit(self, orderId):
4502 
    """
4503 
    Mark order as LOST_IN_TRANSIT
4504 
 
4505 
    Parameters:
4506 
     - orderId
4507 
    """
4508 
    self.send_markOrderAsLostInTransit(orderId)
4509 
    return self.recv_markOrderAsLostInTransit()
4510 
 
4511 
  def send_markOrderAsLostInTransit(self, orderId):
4512 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4513 
    args = markOrderAsLostInTransit_args()
4514 
    args.orderId = orderId
4515 
    args.write(self._oprot)
4516 
    self._oprot.writeMessageEnd()
4517 
    self._oprot.trans.flush()
4518 
 
4519 
  def recv_markOrderAsLostInTransit(self, ):
4520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4521 
    if mtype == TMessageType.EXCEPTION:
4522 
      x = TApplicationException()
4523 
      x.read(self._iprot)
4524 
      self._iprot.readMessageEnd()
4525 
      raise x
4526 
    result = markOrderAsLostInTransit_result()
4527 
    result.read(self._iprot)
4528 
    self._iprot.readMessageEnd()
4529 
    if result.success is not None:
4530 
      return result.success
4531 
    if result.ex is not None:
4532 
      raise result.ex
4533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4534 
 
4386 anupam.sin 4535 
  def getOrderForAwb(self, awb):
4536 
    """
4537 
    Returns the order corresponding to an AWB number
4369 rajveer 4538 
 
4386 anupam.sin 4539 
    Parameters:
4540 
     - awb
4541 
    """
4542 
    self.send_getOrderForAwb(awb)
4543 
    return self.recv_getOrderForAwb()
4544 
 
4545 
  def send_getOrderForAwb(self, awb):
4546 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4547 
    args = getOrderForAwb_args()
4548 
    args.awb = awb
4549 
    args.write(self._oprot)
4550 
    self._oprot.writeMessageEnd()
4551 
    self._oprot.trans.flush()
4552 
 
4553 
  def recv_getOrderForAwb(self, ):
4554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4555 
    if mtype == TMessageType.EXCEPTION:
4556 
      x = TApplicationException()
4557 
      x.read(self._iprot)
4558 
      self._iprot.readMessageEnd()
4559 
      raise x
4560 
    result = getOrderForAwb_result()
4561 
    result.read(self._iprot)
4562 
    self._iprot.readMessageEnd()
4563 
    if result.success is not None:
4564 
      return result.success
4565 
    if result.ex is not None:
4566 
      raise result.ex
4567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4568 
 
4910 phani.kuma 4569 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4570 
    """
4910 phani.kuma 4571 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4572 
 
4506 phani.kuma 4573 
    Parameters:
4574 
     - logistics_provider_id
4910 phani.kuma 4575 
     - order_status_list
4506 phani.kuma 4576 
    """
4910 phani.kuma 4577 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4578 
    return self.recv_getOrdersForProviderForStatus()
4579 
 
4910 phani.kuma 4580 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4581 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4582 
    args = getOrdersForProviderForStatus_args()
4583 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4584 
    args.order_status_list = order_status_list
4506 phani.kuma 4585 
    args.write(self._oprot)
4586 
    self._oprot.writeMessageEnd()
4587 
    self._oprot.trans.flush()
4588 
 
4589 
  def recv_getOrdersForProviderForStatus(self, ):
4590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4591 
    if mtype == TMessageType.EXCEPTION:
4592 
      x = TApplicationException()
4593 
      x.read(self._iprot)
4594 
      self._iprot.readMessageEnd()
4595 
      raise x
4596 
    result = getOrdersForProviderForStatus_result()
4597 
    result.read(self._iprot)
4598 
    self._iprot.readMessageEnd()
4599 
    if result.success is not None:
4600 
      return result.success
4601 
    if result.ex is not None:
4602 
      raise result.ex
4603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4604 
 
4600 varun.gupt 4605 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4606 
    """
4607 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4608 
 
4600 varun.gupt 4609 
    Parameters:
4610 
     - vendorId
4611 
     - billingDateFrom
4612 
     - billingDateTo
4613 
    """
4614 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4615 
    return self.recv_getBilledOrdersForVendor()
4616 
 
4617 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4618 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4619 
    args = getBilledOrdersForVendor_args()
4620 
    args.vendorId = vendorId
4621 
    args.billingDateFrom = billingDateFrom
4622 
    args.billingDateTo = billingDateTo
4623 
    args.write(self._oprot)
4624 
    self._oprot.writeMessageEnd()
4625 
    self._oprot.trans.flush()
4626 
 
4627 
  def recv_getBilledOrdersForVendor(self, ):
4628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4629 
    if mtype == TMessageType.EXCEPTION:
4630 
      x = TApplicationException()
4631 
      x.read(self._iprot)
4632 
      self._iprot.readMessageEnd()
4633 
      raise x
4634 
    result = getBilledOrdersForVendor_result()
4635 
    result.read(self._iprot)
4636 
    self._iprot.readMessageEnd()
4637 
    if result.success is not None:
4638 
      return result.success
4639 
    if result.ex is not None:
4640 
      raise result.ex
4641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4642 
 
4607 rajveer 4643 
  def getSlippedSippingDateOrders(self, ):
4644 
    self.send_getSlippedSippingDateOrders()
4645 
    return self.recv_getSlippedSippingDateOrders()
4646 
 
4647 
  def send_getSlippedSippingDateOrders(self, ):
4648 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4649 
    args = getSlippedSippingDateOrders_args()
4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_getSlippedSippingDateOrders(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = getSlippedSippingDateOrders_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    if result.success is not None:
4665 
      return result.success
4666 
    if result.ex is not None:
4667 
      raise result.ex
4668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4669 
 
4709 rajveer 4670 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4671 
    """
4672 
    Parameters:
4673 
     - cancelDateFrom
4674 
     - cancelDateTo
4675 
    """
4676 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4677 
    return self.recv_getCancelledOrders()
4678 
 
4679 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4680 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4681 
    args = getCancelledOrders_args()
4682 
    args.cancelDateFrom = cancelDateFrom
4683 
    args.cancelDateTo = cancelDateTo
4684 
    args.write(self._oprot)
4685 
    self._oprot.writeMessageEnd()
4686 
    self._oprot.trans.flush()
4687 
 
4688 
  def recv_getCancelledOrders(self, ):
4689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4690 
    if mtype == TMessageType.EXCEPTION:
4691 
      x = TApplicationException()
4692 
      x.read(self._iprot)
4693 
      self._iprot.readMessageEnd()
4694 
      raise x
4695 
    result = getCancelledOrders_result()
4696 
    result.read(self._iprot)
4697 
    self._iprot.readMessageEnd()
4698 
    if result.success is not None:
4699 
      return result.success
4700 
    if result.ex is not None:
4701 
      raise result.ex
4702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4703 
 
4600 varun.gupt 4704 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4705 
    """
4706 
    Parameters:
4707 
     - mapAWBAndAmount
4708 
    """
4709 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4710 
    self.recv_saveBluedartSettlements()
4711 
 
4712 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4713 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4714 
    args = saveBluedartSettlements_args()
4715 
    args.mapAWBAndAmount = mapAWBAndAmount
4716 
    args.write(self._oprot)
4717 
    self._oprot.writeMessageEnd()
4718 
    self._oprot.trans.flush()
4719 
 
4720 
  def recv_saveBluedartSettlements(self, ):
4721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4722 
    if mtype == TMessageType.EXCEPTION:
4723 
      x = TApplicationException()
4724 
      x.read(self._iprot)
4725 
      self._iprot.readMessageEnd()
4726 
      raise x
4727 
    result = saveBluedartSettlements_result()
4728 
    result.read(self._iprot)
4729 
    self._iprot.readMessageEnd()
4730 
    if result.ex is not None:
4731 
      raise result.ex
4732 
    return
4733 
 
4905 varun.gupt 4734 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4735 
    """
4736 
    Parameters:
4737 
     - settlementDate
4738 
     - paymentGatewayId
4905 varun.gupt 4739 
     - referenceId
4600 varun.gupt 4740 
     - serviceTax
4741 
     - otherCharges
4742 
     - netCollection
4743 
    """
4905 varun.gupt 4744 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4745 
    self.recv_savePaymentSettlements()
4746 
 
4905 varun.gupt 4747 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4748 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4749 
    args = savePaymentSettlements_args()
4750 
    args.settlementDate = settlementDate
4751 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4752 
    args.referenceId = referenceId
4600 varun.gupt 4753 
    args.serviceTax = serviceTax
4754 
    args.otherCharges = otherCharges
4755 
    args.netCollection = netCollection
4756 
    args.write(self._oprot)
4757 
    self._oprot.writeMessageEnd()
4758 
    self._oprot.trans.flush()
4759 
 
4760 
  def recv_savePaymentSettlements(self, ):
4761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4762 
    if mtype == TMessageType.EXCEPTION:
4763 
      x = TApplicationException()
4764 
      x.read(self._iprot)
4765 
      self._iprot.readMessageEnd()
4766 
      raise x
4767 
    result = savePaymentSettlements_result()
4768 
    result.read(self._iprot)
4769 
    self._iprot.readMessageEnd()
4770 
    if result.ex is not None:
4771 
      raise result.ex
4772 
    return
4773 
 
4774 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4775 
    """
4776 
    Parameters:
4777 
     - settlementId
4778 
     - settlementDate
4779 
     - transactionDateFrom
4780 
     - transactionDateTo
4781 
     - amount
4782 
    """
4783 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4784 
    self.recv_saveEBSSettlementSummary()
4785 
 
4786 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4787 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4788 
    args = saveEBSSettlementSummary_args()
4789 
    args.settlementId = settlementId
4790 
    args.settlementDate = settlementDate
4791 
    args.transactionDateFrom = transactionDateFrom
4792 
    args.transactionDateTo = transactionDateTo
4793 
    args.amount = amount
4794 
    args.write(self._oprot)
4795 
    self._oprot.writeMessageEnd()
4796 
    self._oprot.trans.flush()
4797 
 
4798 
  def recv_saveEBSSettlementSummary(self, ):
4799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4800 
    if mtype == TMessageType.EXCEPTION:
4801 
      x = TApplicationException()
4802 
      x.read(self._iprot)
4803 
      self._iprot.readMessageEnd()
4804 
      raise x
4805 
    result = saveEBSSettlementSummary_result()
4806 
    result.read(self._iprot)
4807 
    self._iprot.readMessageEnd()
4808 
    if result.ex is not None:
4809 
      raise result.ex
4810 
    return
4811 
 
5386 phani.kuma 4812 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4813 
    """
4814 
    Parameters:
5189 varun.gupt 4815 
     - referenceId
4816 
     - isRefund
4600 varun.gupt 4817 
    """
5386 phani.kuma 4818 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4819 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4820 
 
5386 phani.kuma 4821 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4822 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4823 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4824 
    args.referenceId = referenceId
4825 
    args.isRefund = isRefund
4600 varun.gupt 4826 
    args.write(self._oprot)
4827 
    self._oprot.writeMessageEnd()
4828 
    self._oprot.trans.flush()
4829 
 
5386 phani.kuma 4830 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4832 
    if mtype == TMessageType.EXCEPTION:
4833 
      x = TApplicationException()
4834 
      x.read(self._iprot)
4835 
      self._iprot.readMessageEnd()
4836 
      raise x
5386 phani.kuma 4837 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4838 
    result.read(self._iprot)
4839 
    self._iprot.readMessageEnd()
4840 
    if result.success is not None:
4841 
      return result.success
4842 
    if result.ex is not None:
4843 
      raise result.ex
5386 phani.kuma 4844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4845 
 
5386 phani.kuma 4846 
  def getSettlementForCod(self, orderId, isRefund):
4847 
    """
4848 
    Parameters:
4849 
     - orderId
4850 
     - isRefund
4851 
    """
4852 
    self.send_getSettlementForCod(orderId, isRefund)
4853 
    return self.recv_getSettlementForCod()
4854 
 
4855 
  def send_getSettlementForCod(self, orderId, isRefund):
4856 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4857 
    args = getSettlementForCod_args()
4858 
    args.orderId = orderId
4859 
    args.isRefund = isRefund
4860 
    args.write(self._oprot)
4861 
    self._oprot.writeMessageEnd()
4862 
    self._oprot.trans.flush()
4863 
 
4864 
  def recv_getSettlementForCod(self, ):
4865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4866 
    if mtype == TMessageType.EXCEPTION:
4867 
      x = TApplicationException()
4868 
      x.read(self._iprot)
4869 
      self._iprot.readMessageEnd()
4870 
      raise x
4871 
    result = getSettlementForCod_result()
4872 
    result.read(self._iprot)
4873 
    self._iprot.readMessageEnd()
4874 
    if result.success is not None:
4875 
      return result.success
4876 
    if result.ex is not None:
4877 
      raise result.ex
4878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4879 
 
4600 varun.gupt 4880 
  def getEBSSettlementSummaries(self, ):
4881 
    self.send_getEBSSettlementSummaries()
4882 
    return self.recv_getEBSSettlementSummaries()
4883 
 
4884 
  def send_getEBSSettlementSummaries(self, ):
4885 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4886 
    args = getEBSSettlementSummaries_args()
4887 
    args.write(self._oprot)
4888 
    self._oprot.writeMessageEnd()
4889 
    self._oprot.trans.flush()
4890 
 
4891 
  def recv_getEBSSettlementSummaries(self, ):
4892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4893 
    if mtype == TMessageType.EXCEPTION:
4894 
      x = TApplicationException()
4895 
      x.read(self._iprot)
4896 
      self._iprot.readMessageEnd()
4897 
      raise x
4898 
    result = getEBSSettlementSummaries_result()
4899 
    result.read(self._iprot)
4900 
    self._iprot.readMessageEnd()
4901 
    if result.success is not None:
4902 
      return result.success
4903 
    if result.ex is not None:
4904 
      raise result.ex
4905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4906 
 
4907 
  def markEBSSettlementUploaded(self, settlementId):
4908 
    """
4909 
    Parameters:
4910 
     - settlementId
4911 
    """
4912 
    self.send_markEBSSettlementUploaded(settlementId)
4913 
    self.recv_markEBSSettlementUploaded()
4914 
 
4915 
  def send_markEBSSettlementUploaded(self, settlementId):
4916 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4917 
    args = markEBSSettlementUploaded_args()
4918 
    args.settlementId = settlementId
4919 
    args.write(self._oprot)
4920 
    self._oprot.writeMessageEnd()
4921 
    self._oprot.trans.flush()
4922 
 
4923 
  def recv_markEBSSettlementUploaded(self, ):
4924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4925 
    if mtype == TMessageType.EXCEPTION:
4926 
      x = TApplicationException()
4927 
      x.read(self._iprot)
4928 
      self._iprot.readMessageEnd()
4929 
      raise x
4930 
    result = markEBSSettlementUploaded_result()
4931 
    result.read(self._iprot)
4932 
    self._iprot.readMessageEnd()
4933 
    if result.ex is not None:
4934 
      raise result.ex
4935 
    return
4936 
 
4937 
  def getEBSSettlementDate(self, settlementId):
4938 
    """
4939 
    Parameters:
4940 
     - settlementId
4941 
    """
4942 
    self.send_getEBSSettlementDate(settlementId)
4943 
    return self.recv_getEBSSettlementDate()
4944 
 
4945 
  def send_getEBSSettlementDate(self, settlementId):
4946 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4947 
    args = getEBSSettlementDate_args()
4948 
    args.settlementId = settlementId
4949 
    args.write(self._oprot)
4950 
    self._oprot.writeMessageEnd()
4951 
    self._oprot.trans.flush()
4952 
 
4953 
  def recv_getEBSSettlementDate(self, ):
4954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4955 
    if mtype == TMessageType.EXCEPTION:
4956 
      x = TApplicationException()
4957 
      x.read(self._iprot)
4958 
      self._iprot.readMessageEnd()
4959 
      raise x
4960 
    result = getEBSSettlementDate_result()
4961 
    result.read(self._iprot)
4962 
    self._iprot.readMessageEnd()
4963 
    if result.success is not None:
4964 
      return result.success
4965 
    if result.ex is not None:
4966 
      raise result.ex
4967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4968 
 
4715 varun.gupt 4969 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4970 
    """
4971 
    Parameters:
4972 
     - settlementDateFrom
4973 
     - settlementDateTo
4974 
     - isRefund
4975 
    """
4976 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4977 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4978 
 
4715 varun.gupt 4979 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4980 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4981 
    args = getSettlementsByDate_args()
4982 
    args.settlementDateFrom = settlementDateFrom
4983 
    args.settlementDateTo = settlementDateTo
4984 
    args.isRefund = isRefund
4985 
    args.write(self._oprot)
4986 
    self._oprot.writeMessageEnd()
4987 
    self._oprot.trans.flush()
4988 
 
4989 
  def recv_getSettlementsByDate(self, ):
4990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4991 
    if mtype == TMessageType.EXCEPTION:
4992 
      x = TApplicationException()
4993 
      x.read(self._iprot)
4994 
      self._iprot.readMessageEnd()
4995 
      raise x
4996 
    result = getSettlementsByDate_result()
4997 
    result.read(self._iprot)
4998 
    self._iprot.readMessageEnd()
4999 
    if result.success is not None:
5000 
      return result.success
5001 
    if result.ex is not None:
5002 
      raise result.ex
5003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5004 
 
5005 
  def getReshippedOrderIds(self, orderIds):
5006 
    """
5007 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5008 
 
5009 
    Parameters:
5010 
     - orderIds
5011 
    """
5012 
    self.send_getReshippedOrderIds(orderIds)
5013 
    return self.recv_getReshippedOrderIds()
5014 
 
5015 
  def send_getReshippedOrderIds(self, orderIds):
5016 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5017 
    args = getReshippedOrderIds_args()
5018 
    args.orderIds = orderIds
5019 
    args.write(self._oprot)
5020 
    self._oprot.writeMessageEnd()
5021 
    self._oprot.trans.flush()
5022 
 
5023 
  def recv_getReshippedOrderIds(self, ):
5024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5025 
    if mtype == TMessageType.EXCEPTION:
5026 
      x = TApplicationException()
5027 
      x.read(self._iprot)
5028 
      self._iprot.readMessageEnd()
5029 
      raise x
5030 
    result = getReshippedOrderIds_result()
5031 
    result.read(self._iprot)
5032 
    self._iprot.readMessageEnd()
5033 
    if result.success is not None:
5034 
      return result.success
5035 
    if result.ex is not None:
5036 
      raise result.ex
5037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5038 
 
5481 phani.kuma 5039 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5040 
    """
5041 
    Parameters:
5042 
     - vendorId
5481 phani.kuma 5043 
     - onlyVendorNotPaid
5044 
     - billingDateFrom
5045 
     - billingDateTo
4875 varun.gupt 5046 
    """
5481 phani.kuma 5047 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5048 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5049 
 
5481 phani.kuma 5050 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5051 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5052 
    args = getBilledOrders_args()
4875 varun.gupt 5053 
    args.vendorId = vendorId
5481 phani.kuma 5054 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5055 
    args.billingDateFrom = billingDateFrom
5056 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5057 
    args.write(self._oprot)
5058 
    self._oprot.writeMessageEnd()
5059 
    self._oprot.trans.flush()
5060 
 
5481 phani.kuma 5061 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5063 
    if mtype == TMessageType.EXCEPTION:
5064 
      x = TApplicationException()
5065 
      x.read(self._iprot)
5066 
      self._iprot.readMessageEnd()
5067 
      raise x
5481 phani.kuma 5068 
    result = getBilledOrders_result()
4875 varun.gupt 5069 
    result.read(self._iprot)
5070 
    self._iprot.readMessageEnd()
5071 
    if result.success is not None:
5072 
      return result.success
5073 
    if result.ex is not None:
5074 
      raise result.ex
5481 phani.kuma 5075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5076 
 
5031 varun.gupt 5077 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5078 
    """
5079 
    Parameters:
5080 
     - startDate
5081 
     - endDate
5082 
    """
5083 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5084 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5085 
 
5031 varun.gupt 5086 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5087 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5088 
    args = getStatusDistributionOfOrders_args()
5089 
    args.startDate = startDate
5090 
    args.endDate = endDate
5091 
    args.write(self._oprot)
5092 
    self._oprot.writeMessageEnd()
5093 
    self._oprot.trans.flush()
5094 
 
5095 
  def recv_getStatusDistributionOfOrders(self, ):
5096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5097 
    if mtype == TMessageType.EXCEPTION:
5098 
      x = TApplicationException()
5099 
      x.read(self._iprot)
5100 
      self._iprot.readMessageEnd()
5101 
      raise x
5102 
    result = getStatusDistributionOfOrders_result()
5103 
    result.read(self._iprot)
5104 
    self._iprot.readMessageEnd()
5105 
    if result.success is not None:
5106 
      return result.success
5107 
    if result.ex is not None:
5108 
      raise result.ex
5109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5110 
 
5067 varun.gupt 5111 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5112 
    """
5113 
    Parameters:
5114 
     - status
5115 
     - startDatetime
5116 
     - endDatetime
5117 
    """
5118 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5119 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5120 
 
5067 varun.gupt 5121 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5122 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5123 
    args = getOrderIdsForStatus_args()
5124 
    args.status = status
5125 
    args.startDatetime = startDatetime
5126 
    args.endDatetime = endDatetime
5127 
    args.write(self._oprot)
5128 
    self._oprot.writeMessageEnd()
5129 
    self._oprot.trans.flush()
5130 
 
5131 
  def recv_getOrderIdsForStatus(self, ):
5132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5133 
    if mtype == TMessageType.EXCEPTION:
5134 
      x = TApplicationException()
5135 
      x.read(self._iprot)
5136 
      self._iprot.readMessageEnd()
5137 
      raise x
5138 
    result = getOrderIdsForStatus_result()
5139 
    result.read(self._iprot)
5140 
    self._iprot.readMessageEnd()
5141 
    if result.success is not None:
5142 
      return result.success
5143 
    if result.ex is not None:
5144 
      raise result.ex
5145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5146 
 
5348 anupam.sin 5147 
  def updateCODAgent(self, agent, orderId):
5148 
    """
5149 
    Updates the agent who handled the COD verification call
5150 
 
5151 
    Parameters:
5152 
     - agent
5153 
     - orderId
5154 
    """
5155 
    self.send_updateCODAgent(agent, orderId)
5156 
    self.recv_updateCODAgent()
5157 
 
5158 
  def send_updateCODAgent(self, agent, orderId):
5159 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5160 
    args = updateCODAgent_args()
5161 
    args.agent = agent
5162 
    args.orderId = orderId
5163 
    args.write(self._oprot)
5164 
    self._oprot.writeMessageEnd()
5165 
    self._oprot.trans.flush()
5166 
 
5167 
  def recv_updateCODAgent(self, ):
5168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5169 
    if mtype == TMessageType.EXCEPTION:
5170 
      x = TApplicationException()
5171 
      x.read(self._iprot)
5172 
      self._iprot.readMessageEnd()
5173 
      raise x
5174 
    result = updateCODAgent_result()
5175 
    result.read(self._iprot)
5176 
    self._iprot.readMessageEnd()
5177 
    if result.ex is not None:
5178 
      raise result.ex
5179 
    return
5180 
 
5099 varun.gupt 5181 
  def updateOrderAsPaidToVendor(self, orderId):
5182 
    """
5183 
    Parameters:
5184 
     - orderId
5185 
    """
5186 
    self.send_updateOrderAsPaidToVendor(orderId)
5187 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5188 
 
5099 varun.gupt 5189 
  def send_updateOrderAsPaidToVendor(self, orderId):
5190 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5191 
    args = updateOrderAsPaidToVendor_args()
5192 
    args.orderId = orderId
5193 
    args.write(self._oprot)
5194 
    self._oprot.writeMessageEnd()
5195 
    self._oprot.trans.flush()
5196 
 
5197 
  def recv_updateOrderAsPaidToVendor(self, ):
5198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5199 
    if mtype == TMessageType.EXCEPTION:
5200 
      x = TApplicationException()
5201 
      x.read(self._iprot)
5202 
      self._iprot.readMessageEnd()
5203 
      raise x
5204 
    result = updateOrderAsPaidToVendor_result()
5205 
    result.read(self._iprot)
5206 
    self._iprot.readMessageEnd()
5207 
    if result.ex is not None:
5208 
      raise result.ex
5209 
    return
5210 
 
5386 phani.kuma 5211 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5212 
    """
5213 
    Parameters:
5214 
     - orderId
5215 
    """
5216 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5217 
    self.recv_updateOrderOnlyAsPaidToVendor()
5218 
 
5219 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5220 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5221 
    args = updateOrderOnlyAsPaidToVendor_args()
5222 
    args.orderId = orderId
5223 
    args.write(self._oprot)
5224 
    self._oprot.writeMessageEnd()
5225 
    self._oprot.trans.flush()
5226 
 
5227 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5229 
    if mtype == TMessageType.EXCEPTION:
5230 
      x = TApplicationException()
5231 
      x.read(self._iprot)
5232 
      self._iprot.readMessageEnd()
5233 
      raise x
5234 
    result = updateOrderOnlyAsPaidToVendor_result()
5235 
    result.read(self._iprot)
5236 
    self._iprot.readMessageEnd()
5237 
    if result.ex is not None:
5238 
      raise result.ex
5239 
    return
5240 
 
5208 varun.gupt 5241 
  def getRefundedOrdersMarkedPaid(self, ):
5242 
    self.send_getRefundedOrdersMarkedPaid()
5243 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5244 
 
5208 varun.gupt 5245 
  def send_getRefundedOrdersMarkedPaid(self, ):
5246 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5247 
    args = getRefundedOrdersMarkedPaid_args()
5248 
    args.write(self._oprot)
5249 
    self._oprot.writeMessageEnd()
5250 
    self._oprot.trans.flush()
5251 
 
5252 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5254 
    if mtype == TMessageType.EXCEPTION:
5255 
      x = TApplicationException()
5256 
      x.read(self._iprot)
5257 
      self._iprot.readMessageEnd()
5258 
      raise x
5259 
    result = getRefundedOrdersMarkedPaid_result()
5260 
    result.read(self._iprot)
5261 
    self._iprot.readMessageEnd()
5262 
    if result.success is not None:
5263 
      return result.success
5264 
    if result.ex is not None:
5265 
      raise result.ex
5266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5267 
 
5447 anupam.sin 5268 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5269 
    """
5270 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5271 
 
5447 anupam.sin 5272 
 
5273 
    Parameters:
5274 
     - minOrderId
5275 
     - maxOrderId
5276 
    """
5277 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5278 
    return self.recv_getAllVerificationAgents()
5279 
 
5280 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5281 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5282 
    args = getAllVerificationAgents_args()
5283 
    args.minOrderId = minOrderId
5284 
    args.maxOrderId = maxOrderId
5285 
    args.write(self._oprot)
5286 
    self._oprot.writeMessageEnd()
5287 
    self._oprot.trans.flush()
5288 
 
5289 
  def recv_getAllVerificationAgents(self, ):
5290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5291 
    if mtype == TMessageType.EXCEPTION:
5292 
      x = TApplicationException()
5293 
      x.read(self._iprot)
5294 
      self._iprot.readMessageEnd()
5295 
      raise x
5296 
    result = getAllVerificationAgents_result()
5297 
    result.read(self._iprot)
5298 
    self._iprot.readMessageEnd()
5299 
    if result.success is not None:
5300 
      return result.success
5301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5302 
 
5527 anupam.sin 5303 
  def getAllAttributesForOrderId(self, orderId):
5304 
    """
5305 
    gets all attributes for a given orderId
5447 anupam.sin 5306 
 
5527 anupam.sin 5307 
    Parameters:
5308 
     - orderId
5309 
    """
5310 
    self.send_getAllAttributesForOrderId(orderId)
5311 
    return self.recv_getAllAttributesForOrderId()
5312 
 
5313 
  def send_getAllAttributesForOrderId(self, orderId):
5314 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5315 
    args = getAllAttributesForOrderId_args()
5316 
    args.orderId = orderId
5317 
    args.write(self._oprot)
5318 
    self._oprot.writeMessageEnd()
5319 
    self._oprot.trans.flush()
5320 
 
5321 
  def recv_getAllAttributesForOrderId(self, ):
5322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5323 
    if mtype == TMessageType.EXCEPTION:
5324 
      x = TApplicationException()
5325 
      x.read(self._iprot)
5326 
      self._iprot.readMessageEnd()
5327 
      raise x
5328 
    result = getAllAttributesForOrderId_result()
5329 
    result.read(self._iprot)
5330 
    self._iprot.readMessageEnd()
5331 
    if result.success is not None:
5332 
      return result.success
5333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5334 
 
5335 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5336 
    """
5337 
    sets attributes for all orders in a transaction
5338 
 
5339 
    Parameters:
5340 
     - transactionId
5341 
     - attribute
5342 
    """
5343 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5344 
    self.recv_setOrderAttributeForTransaction()
5345 
 
5346 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5347 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5348 
    args = setOrderAttributeForTransaction_args()
5349 
    args.transactionId = transactionId
5350 
    args.attribute = attribute
5351 
    args.write(self._oprot)
5352 
    self._oprot.writeMessageEnd()
5353 
    self._oprot.trans.flush()
5354 
 
5355 
  def recv_setOrderAttributeForTransaction(self, ):
5356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5357 
    if mtype == TMessageType.EXCEPTION:
5358 
      x = TApplicationException()
5359 
      x.read(self._iprot)
5360 
      self._iprot.readMessageEnd()
5361 
      raise x
5362 
    result = setOrderAttributeForTransaction_result()
5363 
    result.read(self._iprot)
5364 
    self._iprot.readMessageEnd()
5365 
    return
5366 
 
5553 rajveer 5367 
  def getReceivePendingOrders(self, storeId):
5368 
    """
5369 
    Parameters:
5370 
     - storeId
5371 
    """
5372 
    self.send_getReceivePendingOrders(storeId)
5373 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5374 
 
5553 rajveer 5375 
  def send_getReceivePendingOrders(self, storeId):
5376 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5377 
    args = getReceivePendingOrders_args()
5378 
    args.storeId = storeId
5379 
    args.write(self._oprot)
5380 
    self._oprot.writeMessageEnd()
5381 
    self._oprot.trans.flush()
5382 
 
5383 
  def recv_getReceivePendingOrders(self, ):
5384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5385 
    if mtype == TMessageType.EXCEPTION:
5386 
      x = TApplicationException()
5387 
      x.read(self._iprot)
5388 
      self._iprot.readMessageEnd()
5389 
      raise x
5390 
    result = getReceivePendingOrders_result()
5391 
    result.read(self._iprot)
5392 
    self._iprot.readMessageEnd()
5393 
    if result.success is not None:
5394 
      return result.success
5395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5396 
 
5397 
  def getReceivedAtStoreOrders(self, storeId):
5398 
    """
5399 
    Parameters:
5400 
     - storeId
5401 
    """
5402 
    self.send_getReceivedAtStoreOrders(storeId)
5403 
    return self.recv_getReceivedAtStoreOrders()
5404 
 
5405 
  def send_getReceivedAtStoreOrders(self, storeId):
5406 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5407 
    args = getReceivedAtStoreOrders_args()
5408 
    args.storeId = storeId
5409 
    args.write(self._oprot)
5410 
    self._oprot.writeMessageEnd()
5411 
    self._oprot.trans.flush()
5412 
 
5413 
  def recv_getReceivedAtStoreOrders(self, ):
5414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5415 
    if mtype == TMessageType.EXCEPTION:
5416 
      x = TApplicationException()
5417 
      x.read(self._iprot)
5418 
      self._iprot.readMessageEnd()
5419 
      raise x
5420 
    result = getReceivedAtStoreOrders_result()
5421 
    result.read(self._iprot)
5422 
    self._iprot.readMessageEnd()
5423 
    if result.success is not None:
5424 
      return result.success
5425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5426 
 
5427 
 
3376 rajveer 5428 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5429 
  def __init__(self, handler):
3376 rajveer 5430 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5431 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5432 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5433 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5434 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5435 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5436 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5437 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5438 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5439 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5440 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5441 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5442 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5443 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5444 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5445 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5446 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5447 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5448 
    self._processMap["createOrder"] = Processor.process_createOrder
5449 
    self._processMap["getOrder"] = Processor.process_getOrder
5450 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5451 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5452 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5453 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5454 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5455 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5456 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5457 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5458 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5459 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5460 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5461 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5462 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5463 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5464 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5465 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5466 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5467 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5468 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5469 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5470 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5471 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5472 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5473 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5474 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5475 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5476 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5477 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5478 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5479 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5480 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5481 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5482 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5483 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5484 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5485 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5486 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5487 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5488 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5489 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5490 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5491 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5492 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5493 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5494 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5495 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5496 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5497 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5498 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5499 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5500 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5501 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5502 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5503 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5504 
    self._processMap["changeItem"] = Processor.process_changeItem
5505 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5506 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5507 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5508 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5509 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5510 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5511 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5512 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5513 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5514 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5515 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5516 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5517 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5518 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5519 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5520 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5521 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5522 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5523 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5524 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5525 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5526 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5527 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5528 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5529 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5530 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5531 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5532 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5533 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5534 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5535 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5536 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5537 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5538 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5539 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5540 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5541 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5542 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5543 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5544 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5545 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5546 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5547 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5548 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5549 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5550 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
94 ashish 5551 
 
5552 
  def process(self, iprot, oprot):
5553 
    (name, type, seqid) = iprot.readMessageBegin()
5554 
    if name not in self._processMap:
5555 
      iprot.skip(TType.STRUCT)
5556 
      iprot.readMessageEnd()
5557 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5558 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5559 
      x.write(oprot)
5560 
      oprot.writeMessageEnd()
5561 
      oprot.trans.flush()
5562 
      return
5563 
    else:
5564 
      self._processMap[name](self, seqid, iprot, oprot)
5565 
    return True
5566 
 
5567 
  def process_createTransaction(self, seqid, iprot, oprot):
5568 
    args = createTransaction_args()
5569 
    args.read(iprot)
5570 
    iprot.readMessageEnd()
5571 
    result = createTransaction_result()
5572 
    try:
132 ashish 5573 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5574 
    except TransactionServiceException, ex:
5575 
      result.ex = ex
5576 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5577 
    result.write(oprot)
5578 
    oprot.writeMessageEnd()
5579 
    oprot.trans.flush()
5580 
 
5581 
  def process_getTransaction(self, seqid, iprot, oprot):
5582 
    args = getTransaction_args()
5583 
    args.read(iprot)
5584 
    iprot.readMessageEnd()
5585 
    result = getTransaction_result()
5586 
    try:
5587 
      result.success = self._handler.getTransaction(args.id)
5588 
    except TransactionServiceException, ex:
5589 
      result.ex = ex
5590 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5591 
    result.write(oprot)
5592 
    oprot.writeMessageEnd()
5593 
    oprot.trans.flush()
5594 
 
5595 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5596 
    args = getTransactionsForCustomer_args()
5597 
    args.read(iprot)
5598 
    iprot.readMessageEnd()
5599 
    result = getTransactionsForCustomer_result()
5600 
    try:
5601 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5602 
    except TransactionServiceException, ex:
5603 
      result.ex = ex
5604 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5605 
    result.write(oprot)
5606 
    oprot.writeMessageEnd()
5607 
    oprot.trans.flush()
5608 
 
132 ashish 5609 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5610 
    args = getTransactionsForShoppingCartId_args()
5611 
    args.read(iprot)
5612 
    iprot.readMessageEnd()
5613 
    result = getTransactionsForShoppingCartId_result()
5614 
    try:
5615 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5616 
    except TransactionServiceException, ex:
5617 
      result.ex = ex
5618 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5619 
    result.write(oprot)
5620 
    oprot.writeMessageEnd()
5621 
    oprot.trans.flush()
5622 
 
94 ashish 5623 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5624 
    args = getTransactionStatus_args()
5625 
    args.read(iprot)
5626 
    iprot.readMessageEnd()
5627 
    result = getTransactionStatus_result()
5628 
    try:
5629 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5630 
    except TransactionServiceException, ex:
5631 
      result.ex = ex
5632 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5633 
    result.write(oprot)
5634 
    oprot.writeMessageEnd()
5635 
    oprot.trans.flush()
5636 
 
5637 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5638 
    args = changeTransactionStatus_args()
5639 
    args.read(iprot)
5640 
    iprot.readMessageEnd()
5641 
    result = changeTransactionStatus_result()
5642 
    try:
5527 anupam.sin 5643 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5644 
    except TransactionServiceException, ex:
5645 
      result.ex = ex
5646 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5647 
    result.write(oprot)
5648 
    oprot.writeMessageEnd()
5649 
    oprot.trans.flush()
5650 
 
1398 varun.gupt 5651 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5652 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5653 
    args.read(iprot)
5654 
    iprot.readMessageEnd()
1398 varun.gupt 5655 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5656 
    try:
1398 varun.gupt 5657 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5658 
    except TransactionServiceException, ex:
5659 
      result.ex = ex
1398 varun.gupt 5660 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5661 
    result.write(oprot)
5662 
    oprot.writeMessageEnd()
5663 
    oprot.trans.flush()
5664 
 
483 rajveer 5665 
  def process_getAllOrders(self, seqid, iprot, oprot):
5666 
    args = getAllOrders_args()
94 ashish 5667 
    args.read(iprot)
5668 
    iprot.readMessageEnd()
483 rajveer 5669 
    result = getAllOrders_result()
94 ashish 5670 
    try:
4801 anupam.sin 5671 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5672 
    except TransactionServiceException, ex:
5673 
      result.ex = ex
483 rajveer 5674 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5675 
    result.write(oprot)
5676 
    oprot.writeMessageEnd()
5677 
    oprot.trans.flush()
5678 
 
4133 chandransh 5679 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5680 
    args = getOrdersInBatch_args()
5681 
    args.read(iprot)
5682 
    iprot.readMessageEnd()
5683 
    result = getOrdersInBatch_result()
5684 
    try:
5685 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5686 
    except TransactionServiceException, ex:
5687 
      result.ex = ex
5688 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5689 
    result.write(oprot)
5690 
    oprot.writeMessageEnd()
5691 
    oprot.trans.flush()
5692 
 
5693 
  def process_getOrderCount(self, seqid, iprot, oprot):
5694 
    args = getOrderCount_args()
5695 
    args.read(iprot)
5696 
    iprot.readMessageEnd()
5697 
    result = getOrderCount_result()
5698 
    try:
5699 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5700 
    except TransactionServiceException, ex:
5701 
      result.ex = ex
5702 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5703 
    result.write(oprot)
5704 
    oprot.writeMessageEnd()
5705 
    oprot.trans.flush()
5706 
 
999 varun.gupt 5707 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5708 
    args = getOrdersByBillingDate_args()
5709 
    args.read(iprot)
5710 
    iprot.readMessageEnd()
5711 
    result = getOrdersByBillingDate_result()
5712 
    try:
5713 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5714 
    except TransactionServiceException, ex:
5715 
      result.ex = ex
5716 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5717 
    result.write(oprot)
5718 
    oprot.writeMessageEnd()
5719 
    oprot.trans.flush()
5720 
 
3427 chandransh 5721 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5722 
    args = getOrdersByShippingDate_args()
5723 
    args.read(iprot)
5724 
    iprot.readMessageEnd()
5725 
    result = getOrdersByShippingDate_result()
5726 
    try:
3451 chandransh 5727 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5728 
    except TransactionServiceException, ex:
5729 
      result.ex = ex
5730 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5731 
    result.write(oprot)
5732 
    oprot.writeMessageEnd()
5733 
    oprot.trans.flush()
5734 
 
1382 varun.gupt 5735 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5736 
    args = getReturnableOrdersForCustomer_args()
5737 
    args.read(iprot)
5738 
    iprot.readMessageEnd()
5739 
    result = getReturnableOrdersForCustomer_result()
5740 
    try:
5741 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5742 
    except TransactionServiceException, ex:
5743 
      result.ex = ex
5744 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5745 
    result.write(oprot)
5746 
    oprot.writeMessageEnd()
5747 
    oprot.trans.flush()
5748 
 
5749 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5750 
    args = getCancellableOrdersForCustomer_args()
5751 
    args.read(iprot)
5752 
    iprot.readMessageEnd()
5753 
    result = getCancellableOrdersForCustomer_result()
5754 
    try:
5755 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5756 
    except TransactionServiceException, ex:
5757 
      result.ex = ex
5758 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5759 
    result.write(oprot)
5760 
    oprot.writeMessageEnd()
5761 
    oprot.trans.flush()
5762 
 
483 rajveer 5763 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5764 
    args = changeOrderStatus_args()
94 ashish 5765 
    args.read(iprot)
5766 
    iprot.readMessageEnd()
483 rajveer 5767 
    result = changeOrderStatus_result()
94 ashish 5768 
    try:
483 rajveer 5769 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5770 
    except TransactionServiceException, ex:
5771 
      result.ex = ex
483 rajveer 5772 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5773 
    result.write(oprot)
5774 
    oprot.writeMessageEnd()
5775 
    oprot.trans.flush()
5776 
 
483 rajveer 5777 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5778 
    args = getOrdersForTransaction_args()
94 ashish 5779 
    args.read(iprot)
5780 
    iprot.readMessageEnd()
483 rajveer 5781 
    result = getOrdersForTransaction_result()
94 ashish 5782 
    try:
1528 ankur.sing 5783 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5784 
    except TransactionServiceException, ex:
5785 
      result.ex = ex
483 rajveer 5786 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5787 
    result.write(oprot)
5788 
    oprot.writeMessageEnd()
5789 
    oprot.trans.flush()
5790 
 
483 rajveer 5791 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5792 
    args = getOrdersForCustomer_args()
94 ashish 5793 
    args.read(iprot)
5794 
    iprot.readMessageEnd()
483 rajveer 5795 
    result = getOrdersForCustomer_result()
94 ashish 5796 
    try:
3014 chandransh 5797 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5798 
    except TransactionServiceException, ex:
5799 
      result.ex = ex
483 rajveer 5800 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5801 
    result.write(oprot)
5802 
    oprot.writeMessageEnd()
5803 
    oprot.trans.flush()
5804 
 
483 rajveer 5805 
  def process_createOrder(self, seqid, iprot, oprot):
5806 
    args = createOrder_args()
94 ashish 5807 
    args.read(iprot)
5808 
    iprot.readMessageEnd()
483 rajveer 5809 
    result = createOrder_result()
94 ashish 5810 
    try:
483 rajveer 5811 
      result.success = self._handler.createOrder(args.order)
94 ashish 5812 
    except TransactionServiceException, ex:
5813 
      result.ex = ex
483 rajveer 5814 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5815 
    result.write(oprot)
5816 
    oprot.writeMessageEnd()
5817 
    oprot.trans.flush()
5818 
 
483 rajveer 5819 
  def process_getOrder(self, seqid, iprot, oprot):
5820 
    args = getOrder_args()
94 ashish 5821 
    args.read(iprot)
5822 
    iprot.readMessageEnd()
483 rajveer 5823 
    result = getOrder_result()
94 ashish 5824 
    try:
483 rajveer 5825 
      result.success = self._handler.getOrder(args.id)
94 ashish 5826 
    except TransactionServiceException, ex:
5827 
      result.ex = ex
483 rajveer 5828 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5829 
    result.write(oprot)
5830 
    oprot.writeMessageEnd()
5831 
    oprot.trans.flush()
5832 
 
483 rajveer 5833 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5834 
    args = getLineItemsForOrder_args()
94 ashish 5835 
    args.read(iprot)
5836 
    iprot.readMessageEnd()
483 rajveer 5837 
    result = getLineItemsForOrder_result()
94 ashish 5838 
    try:
483 rajveer 5839 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5840 
    except TransactionServiceException, ex:
5841 
      result.ex = ex
483 rajveer 5842 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5843 
    result.write(oprot)
5844 
    oprot.writeMessageEnd()
5845 
    oprot.trans.flush()
5846 
 
4999 phani.kuma 5847 
  def process_getOrderList(self, seqid, iprot, oprot):
5848 
    args = getOrderList_args()
5849 
    args.read(iprot)
5850 
    iprot.readMessageEnd()
5851 
    result = getOrderList_result()
5852 
    result.success = self._handler.getOrderList(args.order_ids)
5853 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5854 
    result.write(oprot)
5855 
    oprot.writeMessageEnd()
5856 
    oprot.trans.flush()
5857 
 
5386 phani.kuma 5858 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5859 
    args = getOrderListForVendor_args()
5860 
    args.read(iprot)
5861 
    iprot.readMessageEnd()
5862 
    result = getOrderListForVendor_result()
5863 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5864 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5865 
    result.write(oprot)
5866 
    oprot.writeMessageEnd()
5867 
    oprot.trans.flush()
5868 
 
1528 ankur.sing 5869 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5870 
    args = getOrderForCustomer_args()
5871 
    args.read(iprot)
5872 
    iprot.readMessageEnd()
5873 
    result = getOrderForCustomer_result()
5874 
    try:
5875 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5876 
    except TransactionServiceException, ex:
5877 
      result.ex = ex
5878 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5879 
    result.write(oprot)
5880 
    oprot.writeMessageEnd()
5881 
    oprot.trans.flush()
5882 
 
3064 chandransh 5883 
  def process_getAlerts(self, seqid, iprot, oprot):
5884 
    args = getAlerts_args()
5885 
    args.read(iprot)
5886 
    iprot.readMessageEnd()
5887 
    result = getAlerts_result()
4444 rajveer 5888 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5889 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5890 
    result.write(oprot)
5891 
    oprot.writeMessageEnd()
5892 
    oprot.trans.flush()
5893 
 
4394 rajveer 5894 
  def process_addAlert(self, seqid, iprot, oprot):
5895 
    args = addAlert_args()
3064 chandransh 5896 
    args.read(iprot)
5897 
    iprot.readMessageEnd()
4394 rajveer 5898 
    result = addAlert_result()
4444 rajveer 5899 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5900 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5901 
    result.write(oprot)
5902 
    oprot.writeMessageEnd()
5903 
    oprot.trans.flush()
5904 
 
4444 rajveer 5905 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5906 
    args = markAlertsAsSeen_args()
5907 
    args.read(iprot)
5908 
    iprot.readMessageEnd()
5909 
    result = markAlertsAsSeen_result()
5910 
    self._handler.markAlertsAsSeen(args.warehouseId)
5911 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5912 
    result.write(oprot)
5913 
    oprot.writeMessageEnd()
5914 
    oprot.trans.flush()
5915 
 
3064 chandransh 5916 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5917 
    args = getValidOrderCount_args()
5918 
    args.read(iprot)
5919 
    iprot.readMessageEnd()
5920 
    result = getValidOrderCount_result()
5921 
    result.success = self._handler.getValidOrderCount()
5922 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5923 
    result.write(oprot)
5924 
    oprot.writeMessageEnd()
5925 
    oprot.trans.flush()
5926 
 
5927 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5928 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5929 
    args.read(iprot)
5930 
    iprot.readMessageEnd()
5931 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5932 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5933 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5934 
    result.write(oprot)
5935 
    oprot.writeMessageEnd()
5936 
    oprot.trans.flush()
5937 
 
5938 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5939 
    args = getValidOrdersAmountRange_args()
5940 
    args.read(iprot)
5941 
    iprot.readMessageEnd()
5942 
    result = getValidOrdersAmountRange_result()
5943 
    result.success = self._handler.getValidOrdersAmountRange()
5944 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5945 
    result.write(oprot)
5946 
    oprot.writeMessageEnd()
5947 
    oprot.trans.flush()
5948 
 
5949 
  def process_getValidOrders(self, seqid, iprot, oprot):
5950 
    args = getValidOrders_args()
5951 
    args.read(iprot)
5952 
    iprot.readMessageEnd()
5953 
    result = getValidOrders_result()
5954 
    result.success = self._handler.getValidOrders(args.limit)
5955 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5956 
    result.write(oprot)
5957 
    oprot.writeMessageEnd()
5958 
    oprot.trans.flush()
5959 
 
1220 chandransh 5960 
  def process_batchOrders(self, seqid, iprot, oprot):
5961 
    args = batchOrders_args()
5962 
    args.read(iprot)
5963 
    iprot.readMessageEnd()
5964 
    result = batchOrders_result()
5965 
    try:
5966 
      result.success = self._handler.batchOrders(args.warehouseId)
5967 
    except TransactionServiceException, ex:
5968 
      result.ex = ex
5969 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
5973 
 
1208 chandransh 5974 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5975 
    args = markOrderAsOutOfStock_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = markOrderAsOutOfStock_result()
5979 
    try:
5980 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5981 
    except TransactionServiceException, ex:
5982 
      result.ex = ex
5983 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5984 
    result.write(oprot)
5985 
    oprot.writeMessageEnd()
5986 
    oprot.trans.flush()
5987 
 
3064 chandransh 5988 
  def process_verifyOrder(self, seqid, iprot, oprot):
5989 
    args = verifyOrder_args()
759 chandransh 5990 
    args.read(iprot)
5991 
    iprot.readMessageEnd()
3064 chandransh 5992 
    result = verifyOrder_result()
759 chandransh 5993 
    try:
3064 chandransh 5994 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5995 
    except TransactionServiceException, ex:
5996 
      result.ex = ex
3064 chandransh 5997 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5998 
    result.write(oprot)
5999 
    oprot.writeMessageEnd()
6000 
    oprot.trans.flush()
6001 
 
3064 chandransh 6002 
  def process_acceptOrder(self, seqid, iprot, oprot):
6003 
    args = acceptOrder_args()
1113 chandransh 6004 
    args.read(iprot)
6005 
    iprot.readMessageEnd()
3064 chandransh 6006 
    result = acceptOrder_result()
1113 chandransh 6007 
    try:
3064 chandransh 6008 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6009 
    except TransactionServiceException, ex:
6010 
      result.ex = ex
3064 chandransh 6011 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
3064 chandransh 6016 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6017 
    args = addBillingDetails_args()
1135 chandransh 6018 
    args.read(iprot)
6019 
    iprot.readMessageEnd()
3064 chandransh 6020 
    result = addBillingDetails_result()
1135 chandransh 6021 
    try:
5110 mandeep.dh 6022 
      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 6023 
    except TransactionServiceException, ex:
6024 
      result.ex = ex
3064 chandransh 6025 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6029 
 
4579 rajveer 6030 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6031 
    args = addInvoiceNumber_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = addInvoiceNumber_result()
6035 
    try:
4763 rajveer 6036 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6037 
    except TransactionServiceException, ex:
6038 
      result.ex = ex
6039 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
4410 rajveer 6044 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6045 
    args = markOrdersAsShippedFromWarehouse_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = markOrdersAsShippedFromWarehouse_result()
6049 
    try:
4789 rajveer 6050 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6051 
    except TransactionServiceException, ex:
6052 
      result.ex = ex
6053 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
3064 chandransh 6058 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6059 
    args = markOrdersAsPickedUp_args()
304 ashish 6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
3064 chandransh 6062 
    result = markOrdersAsPickedUp_result()
6063 
    try:
4910 phani.kuma 6064 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6065 
    except TransactionServiceException, ex:
6066 
      result.ex = ex
6067 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6068 
    result.write(oprot)
6069 
    oprot.writeMessageEnd()
6070 
    oprot.trans.flush()
94 ashish 6071 
 
4910 phani.kuma 6072 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6073 
    args = getOrdersNotPickedUp_args()
6074 
    args.read(iprot)
6075 
    iprot.readMessageEnd()
6076 
    result = getOrdersNotPickedUp_result()
6077 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6078 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
6082 
 
3064 chandransh 6083 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6084 
    args = markOrdersAsDelivered_args()
304 ashish 6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
3064 chandransh 6087 
    result = markOrdersAsDelivered_result()
6088 
    try:
6089 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6090 
    except TransactionServiceException, ex:
6091 
      result.ex = ex
6092 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
6096 
 
4910 phani.kuma 6097 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6098 
    args = markAsRTOrders_args()
1596 ankur.sing 6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
4910 phani.kuma 6101 
    result = markAsRTOrders_result()
3064 chandransh 6102 
    try:
4910 phani.kuma 6103 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6104 
    except TransactionServiceException, ex:
6105 
      result.ex = ex
4910 phani.kuma 6106 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
304 ashish 6110 
 
4910 phani.kuma 6111 
  def process_getRTOrders(self, seqid, iprot, oprot):
6112 
    args = getRTOrders_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = getRTOrders_result()
6116 
    result.success = self._handler.getRTOrders(args.providerId)
6117 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6118 
    result.write(oprot)
6119 
    oprot.writeMessageEnd()
6120 
    oprot.trans.flush()
6121 
 
3064 chandransh 6122 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6123 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6124 
    args.read(iprot)
6125 
    iprot.readMessageEnd()
3064 chandransh 6126 
    result = updateNonDeliveryReason_result()
6127 
    try:
4910 phani.kuma 6128 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6129 
    except TransactionServiceException, ex:
6130 
      result.ex = ex
6131 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
1596 ankur.sing 6135 
 
4910 phani.kuma 6136 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6137 
    args = getNonDeliveredOrdersbyCourier_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = getNonDeliveredOrdersbyCourier_result()
6141 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6142 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
6146 
 
6147 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6148 
    args = markOrdersAsLocalConnected_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = markOrdersAsLocalConnected_result()
6152 
    try:
6153 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
6161 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6162 
    args = getOrdersNotLocalConnected_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = getOrdersNotLocalConnected_result()
6166 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6167 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6168 
    result.write(oprot)
6169 
    oprot.writeMessageEnd()
6170 
    oprot.trans.flush()
6171 
 
6172 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6173 
    args = markOrdersAsDestinationCityReached_args()
6174 
    args.read(iprot)
6175 
    iprot.readMessageEnd()
6176 
    result = markOrdersAsDestinationCityReached_result()
6177 
    try:
6178 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6179 
    except TransactionServiceException, ex:
6180 
      result.ex = ex
6181 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6182 
    result.write(oprot)
6183 
    oprot.writeMessageEnd()
6184 
    oprot.trans.flush()
6185 
 
6186 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6187 
    args = markOrdersAsFirstDeliveryAttempted_args()
6188 
    args.read(iprot)
6189 
    iprot.readMessageEnd()
6190 
    result = markOrdersAsFirstDeliveryAttempted_result()
6191 
    try:
6192 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6193 
    except TransactionServiceException, ex:
6194 
      result.ex = ex
6195 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6196 
    result.write(oprot)
6197 
    oprot.writeMessageEnd()
6198 
    oprot.trans.flush()
6199 
 
3064 chandransh 6200 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6201 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6202 
    args.read(iprot)
6203 
    iprot.readMessageEnd()
3064 chandransh 6204 
    result = getUndeliveredOrders_result()
6205 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6206 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
4783 phani.kuma 6211 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6212 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6216 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6217 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6218 
    result.write(oprot)
6219 
    oprot.writeMessageEnd()
6220 
    oprot.trans.flush()
6221 
 
2536 chandransh 6222 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6223 
    args = toggleDOAFlag_args()
6224 
    args.read(iprot)
6225 
    iprot.readMessageEnd()
6226 
    result = toggleDOAFlag_result()
6227 
    try:
6228 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6229 
    except TransactionServiceException, ex:
6230 
      result.ex = ex
6231 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6232 
    result.write(oprot)
6233 
    oprot.writeMessageEnd()
6234 
    oprot.trans.flush()
1886 ankur.sing 6235 
 
4712 rajveer 6236 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6237 
    args = markOrderAsDelivered_args()
6238 
    args.read(iprot)
6239 
    iprot.readMessageEnd()
6240 
    result = markOrderAsDelivered_result()
6241 
    try:
6242 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6243 
    except TransactionServiceException, ex:
6244 
      result.ex = ex
6245 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6246 
    result.write(oprot)
6247 
    oprot.writeMessageEnd()
6248 
    oprot.trans.flush()
6249 
 
5553 rajveer 6250 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6251 
    args = markOrderAsReceivedAtStore_args()
6252 
    args.read(iprot)
6253 
    iprot.readMessageEnd()
6254 
    result = markOrderAsReceivedAtStore_result()
6255 
    try:
6256 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6257 
    except TransactionServiceException, ex:
6258 
      result.ex = ex
6259 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6260 
    result.write(oprot)
6261 
    oprot.writeMessageEnd()
6262 
    oprot.trans.flush()
6263 
 
4454 rajveer 6264 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6265 
    args = markOrderDoaRequestReceived_args()
6266 
    args.read(iprot)
6267 
    iprot.readMessageEnd()
6268 
    result = markOrderDoaRequestReceived_result()
6269 
    try:
6270 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6271 
    except TransactionServiceException, ex:
6272 
      result.ex = ex
6273 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6274 
    result.write(oprot)
6275 
    oprot.writeMessageEnd()
6276 
    oprot.trans.flush()
6277 
 
6278 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6279 
    args = markOrderDoaRequestAuthorized_args()
6280 
    args.read(iprot)
6281 
    iprot.readMessageEnd()
6282 
    result = markOrderDoaRequestAuthorized_result()
6283 
    try:
6284 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6285 
    except TransactionServiceException, ex:
6286 
      result.ex = ex
6287 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6288 
    result.write(oprot)
6289 
    oprot.writeMessageEnd()
6290 
    oprot.trans.flush()
6291 
 
4488 rajveer 6292 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6293 
    args = markOrderReturnRequestReceived_args()
6294 
    args.read(iprot)
6295 
    iprot.readMessageEnd()
6296 
    result = markOrderReturnRequestReceived_result()
6297 
    try:
6298 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6299 
    except TransactionServiceException, ex:
6300 
      result.ex = ex
6301 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6302 
    result.write(oprot)
6303 
    oprot.writeMessageEnd()
6304 
    oprot.trans.flush()
6305 
 
6306 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6307 
    args = markOrderReturnRequestAuthorized_args()
6308 
    args.read(iprot)
6309 
    iprot.readMessageEnd()
6310 
    result = markOrderReturnRequestAuthorized_result()
6311 
    try:
6312 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6313 
    except TransactionServiceException, ex:
6314 
      result.ex = ex
6315 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6316 
    result.write(oprot)
6317 
    oprot.writeMessageEnd()
6318 
    oprot.trans.flush()
6319 
 
2536 chandransh 6320 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6321 
    args = requestPickupNumber_args()
6322 
    args.read(iprot)
6323 
    iprot.readMessageEnd()
6324 
    result = requestPickupNumber_result()
6325 
    try:
4579 rajveer 6326 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6327 
    except TransactionServiceException, ex:
6328 
      result.ex = ex
6329 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6330 
    result.write(oprot)
6331 
    oprot.writeMessageEnd()
6332 
    oprot.trans.flush()
6333 
 
6334 
  def process_authorizePickup(self, seqid, iprot, oprot):
6335 
    args = authorizePickup_args()
6336 
    args.read(iprot)
6337 
    iprot.readMessageEnd()
6338 
    result = authorizePickup_result()
6339 
    try:
4602 rajveer 6340 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6341 
    except TransactionServiceException, ex:
6342 
      result.ex = ex
6343 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
2764 chandransh 6348 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6349 
    args = markDoasAsPickedUp_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6353 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6354 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
6358 
 
4910 phani.kuma 6359 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6360 
    args = getDoasNotPickedUp_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = getDoasNotPickedUp_result()
6364 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6365 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6366 
    result.write(oprot)
6367 
    oprot.writeMessageEnd()
6368 
    oprot.trans.flush()
6369 
 
4741 phani.kuma 6370 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6371 
    args = markReturnOrdersAsPickedUp_args()
6372 
    args.read(iprot)
6373 
    iprot.readMessageEnd()
6374 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6375 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6376 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
6380 
 
4910 phani.kuma 6381 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6382 
    args = getReturnOrdersNotPickedUp_args()
6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
6385 
    result = getReturnOrdersNotPickedUp_result()
6386 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6387 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
6391 
 
2616 chandransh 6392 
  def process_receiveReturn(self, seqid, iprot, oprot):
6393 
    args = receiveReturn_args()
2591 chandransh 6394 
    args.read(iprot)
6395 
    iprot.readMessageEnd()
2616 chandransh 6396 
    result = receiveReturn_result()
2591 chandransh 6397 
    try:
4479 rajveer 6398 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6399 
    except TransactionServiceException, ex:
6400 
      result.ex = ex
2616 chandransh 6401 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6402 
    result.write(oprot)
6403 
    oprot.writeMessageEnd()
6404 
    oprot.trans.flush()
2536 chandransh 6405 
 
2591 chandransh 6406 
  def process_validateDoa(self, seqid, iprot, oprot):
6407 
    args = validateDoa_args()
6408 
    args.read(iprot)
6409 
    iprot.readMessageEnd()
6410 
    result = validateDoa_result()
6411 
    try:
6412 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6413 
    except TransactionServiceException, ex:
6414 
      result.ex = ex
6415 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6416 
    result.write(oprot)
6417 
    oprot.writeMessageEnd()
6418 
    oprot.trans.flush()
6419 
 
4495 rajveer 6420 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6421 
    args = validateReturnProduct_args()
6422 
    args.read(iprot)
6423 
    iprot.readMessageEnd()
6424 
    result = validateReturnProduct_result()
6425 
    try:
6426 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6427 
    except TransactionServiceException, ex:
6428 
      result.ex = ex
6429 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6430 
    result.write(oprot)
6431 
    oprot.writeMessageEnd()
6432 
    oprot.trans.flush()
6433 
 
2616 chandransh 6434 
  def process_reshipOrder(self, seqid, iprot, oprot):
6435 
    args = reshipOrder_args()
6436 
    args.read(iprot)
6437 
    iprot.readMessageEnd()
6438 
    result = reshipOrder_result()
6439 
    try:
6440 
      result.success = self._handler.reshipOrder(args.orderId)
6441 
    except TransactionServiceException, ex:
6442 
      result.ex = ex
6443 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6444 
    result.write(oprot)
6445 
    oprot.writeMessageEnd()
6446 
    oprot.trans.flush()
2591 chandransh 6447 
 
2616 chandransh 6448 
  def process_refundOrder(self, seqid, iprot, oprot):
6449 
    args = refundOrder_args()
6450 
    args.read(iprot)
6451 
    iprot.readMessageEnd()
6452 
    result = refundOrder_result()
6453 
    try:
3226 chandransh 6454 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6455 
    except TransactionServiceException, ex:
6456 
      result.ex = ex
6457 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6458 
    result.write(oprot)
6459 
    oprot.writeMessageEnd()
6460 
    oprot.trans.flush()
6461 
 
2690 chandransh 6462 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6463 
    args = getReturnOrders_args()
6464 
    args.read(iprot)
6465 
    iprot.readMessageEnd()
6466 
    result = getReturnOrders_result()
6467 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6468 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6469 
    result.write(oprot)
6470 
    oprot.writeMessageEnd()
6471 
    oprot.trans.flush()
2616 chandransh 6472 
 
5481 phani.kuma 6473 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6474 
    args = getAllReturnOrders_args()
6475 
    args.read(iprot)
6476 
    iprot.readMessageEnd()
6477 
    result = getAllReturnOrders_result()
6478 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6479 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6480 
    result.write(oprot)
6481 
    oprot.writeMessageEnd()
6482 
    oprot.trans.flush()
6483 
 
2700 chandransh 6484 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6485 
    args = getReturnOrder_args()
6486 
    args.read(iprot)
6487 
    iprot.readMessageEnd()
6488 
    result = getReturnOrder_result()
6489 
    try:
6490 
      result.success = self._handler.getReturnOrder(args.id)
6491 
    except TransactionServiceException, ex:
6492 
      result.ex = ex
6493 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6494 
    result.write(oprot)
6495 
    oprot.writeMessageEnd()
6496 
    oprot.trans.flush()
6497 
 
2690 chandransh 6498 
  def process_processReturn(self, seqid, iprot, oprot):
6499 
    args = processReturn_args()
6500 
    args.read(iprot)
6501 
    iprot.readMessageEnd()
6502 
    result = processReturn_result()
6503 
    try:
6504 
      self._handler.processReturn(args.returnOrderId)
6505 
    except TransactionServiceException, ex:
6506 
      result.ex = ex
6507 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6508 
    result.write(oprot)
6509 
    oprot.writeMessageEnd()
6510 
    oprot.trans.flush()
6511 
 
3451 chandransh 6512 
  def process_updateWeight(self, seqid, iprot, oprot):
6513 
    args = updateWeight_args()
6514 
    args.read(iprot)
6515 
    iprot.readMessageEnd()
6516 
    result = updateWeight_result()
6517 
    try:
6518 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6519 
    except TransactionServiceException, ex:
6520 
      result.ex = ex
6521 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6522 
    result.write(oprot)
6523 
    oprot.writeMessageEnd()
6524 
    oprot.trans.flush()
2819 chandransh 6525 
 
3469 chandransh 6526 
  def process_changeItem(self, seqid, iprot, oprot):
6527 
    args = changeItem_args()
6528 
    args.read(iprot)
6529 
    iprot.readMessageEnd()
6530 
    result = changeItem_result()
6531 
    try:
6532 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6533 
    except TransactionServiceException, ex:
6534 
      result.ex = ex
6535 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6536 
    result.write(oprot)
6537 
    oprot.writeMessageEnd()
6538 
    oprot.trans.flush()
3451 chandransh 6539 
 
3469 chandransh 6540 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6541 
    args = shiftToWarehouse_args()
6542 
    args.read(iprot)
6543 
    iprot.readMessageEnd()
6544 
    result = shiftToWarehouse_result()
6545 
    try:
6546 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6547 
    except TransactionServiceException, ex:
6548 
      result.ex = ex
6549 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6550 
    result.write(oprot)
6551 
    oprot.writeMessageEnd()
6552 
    oprot.trans.flush()
6553 
 
3553 chandransh 6554 
  def process_addDelayReason(self, seqid, iprot, oprot):
6555 
    args = addDelayReason_args()
6556 
    args.read(iprot)
6557 
    iprot.readMessageEnd()
6558 
    result = addDelayReason_result()
6559 
    try:
4647 rajveer 6560 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6561 
    except TransactionServiceException, ex:
6562 
      result.ex = ex
6563 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6564 
    result.write(oprot)
6565 
    oprot.writeMessageEnd()
6566 
    oprot.trans.flush()
3469 chandransh 6567 
 
3956 chandransh 6568 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6569 
    args = reconcileCodCollection_args()
6570 
    args.read(iprot)
6571 
    iprot.readMessageEnd()
6572 
    result = reconcileCodCollection_result()
6573 
    try:
6574 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6575 
    except TransactionServiceException, ex:
6576 
      result.ex = ex
6577 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6578 
    result.write(oprot)
6579 
    oprot.writeMessageEnd()
6580 
    oprot.trans.flush()
3553 chandransh 6581 
 
4008 mandeep.dh 6582 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6583 
    args = getTransactionsRequiringExtraProcessing_args()
6584 
    args.read(iprot)
6585 
    iprot.readMessageEnd()
6586 
    result = getTransactionsRequiringExtraProcessing_result()
6587 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6588 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
3956 chandransh 6592 
 
4008 mandeep.dh 6593 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6594 
    args = markTransactionAsProcessed_args()
6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
6597 
    result = markTransactionAsProcessed_result()
6598 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6599 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
4018 chandransh 6604 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6605 
    args = getItemWiseRiskyOrdersCount_args()
6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
6608 
    result = getItemWiseRiskyOrdersCount_result()
6609 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6610 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
4008 mandeep.dh 6614 
 
4295 varun.gupt 6615 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6616 
    args = getOrdersForItemIds_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getOrdersForItemIds_result()
6620 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6621 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6622 
    result.write(oprot)
6623 
    oprot.writeMessageEnd()
6624 
    oprot.trans.flush()
6625 
 
4247 rajveer 6626 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6627 
    args = markOrderCancellationRequestReceived_args()
6628 
    args.read(iprot)
6629 
    iprot.readMessageEnd()
6630 
    result = markOrderCancellationRequestReceived_result()
6631 
    try:
6632 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6633 
    except TransactionServiceException, ex:
6634 
      result.ex = ex
6635 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6636 
    result.write(oprot)
6637 
    oprot.writeMessageEnd()
6638 
    oprot.trans.flush()
4018 chandransh 6639 
 
4247 rajveer 6640 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6641 
    args = markOrderCancellationRequestConfirmed_args()
6642 
    args.read(iprot)
6643 
    iprot.readMessageEnd()
6644 
    result = markOrderCancellationRequestConfirmed_result()
6645 
    try:
6646 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6647 
    except TransactionServiceException, ex:
6648 
      result.ex = ex
6649 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6650 
    result.write(oprot)
6651 
    oprot.writeMessageEnd()
6652 
    oprot.trans.flush()
6653 
 
6654 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6655 
    args = markOrderCancellationRequestDenied_args()
6656 
    args.read(iprot)
6657 
    iprot.readMessageEnd()
6658 
    result = markOrderCancellationRequestDenied_result()
6659 
    try:
6660 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6661 
    except TransactionServiceException, ex:
6662 
      result.ex = ex
6663 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6664 
    result.write(oprot)
6665 
    oprot.writeMessageEnd()
6666 
    oprot.trans.flush()
6667 
 
4258 rajveer 6668 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6669 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6670 
    args.read(iprot)
6671 
    iprot.readMessageEnd()
4258 rajveer 6672 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6673 
    try:
4258 rajveer 6674 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6675 
    except TransactionServiceException, ex:
6676 
      result.ex = ex
4258 rajveer 6677 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6678 
    result.write(oprot)
6679 
    oprot.writeMessageEnd()
6680 
    oprot.trans.flush()
6681 
 
4259 anupam.sin 6682 
  def process_refundTransaction(self, seqid, iprot, oprot):
6683 
    args = refundTransaction_args()
6684 
    args.read(iprot)
6685 
    iprot.readMessageEnd()
6686 
    result = refundTransaction_result()
6687 
    try:
6688 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6689 
    except TransactionServiceException, ex:
6690 
      result.ex = ex
6691 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6692 
    result.write(oprot)
6693 
    oprot.writeMessageEnd()
6694 
    oprot.trans.flush()
4247 rajveer 6695 
 
4324 mandeep.dh 6696 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6697 
    args = updateShipmentAddress_args()
6698 
    args.read(iprot)
6699 
    iprot.readMessageEnd()
6700 
    result = updateShipmentAddress_result()
6701 
    try:
6702 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6703 
    except TransactionServiceException, ex:
6704 
      result.ex = ex
6705 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6706 
    result.write(oprot)
6707 
    oprot.writeMessageEnd()
6708 
    oprot.trans.flush()
6709 
 
4285 rajveer 6710 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6711 
    args = acceptOrdersForItemId_args()
6712 
    args.read(iprot)
6713 
    iprot.readMessageEnd()
6714 
    result = acceptOrdersForItemId_result()
6715 
    try:
6716 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6717 
    except TransactionServiceException, ex:
6718 
      result.ex = ex
6719 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
4259 anupam.sin 6723 
 
4303 rajveer 6724 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6725 
    args = markOrdersAsPORaised_args()
6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
6728 
    result = markOrdersAsPORaised_result()
6729 
    try:
4369 rajveer 6730 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6731 
    except TransactionServiceException, ex:
6732 
      result.ex = ex
6733 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
4285 rajveer 6737 
 
4303 rajveer 6738 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6739 
    args = markOrdersAsReversalInitiated_args()
6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
6742 
    result = markOrdersAsReversalInitiated_result()
6743 
    try:
4369 rajveer 6744 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6745 
    except TransactionServiceException, ex:
6746 
      result.ex = ex
6747 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
6752 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6753 
    args = markOrdersAsNotAvailabke_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = markOrdersAsNotAvailabke_result()
6757 
    try:
4369 rajveer 6758 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6759 
    except TransactionServiceException, ex:
6760 
      result.ex = ex
6761 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
6765 
 
4369 rajveer 6766 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6767 
    args = markOrdersAsTimeout_args()
6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
6770 
    result = markOrdersAsTimeout_result()
6771 
    try:
6772 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6773 
    except TransactionServiceException, ex:
6774 
      result.ex = ex
6775 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6776 
    result.write(oprot)
6777 
    oprot.writeMessageEnd()
6778 
    oprot.trans.flush()
4303 rajveer 6779 
 
4662 rajveer 6780 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6781 
    args = markOrderAsLostInTransit_args()
6782 
    args.read(iprot)
6783 
    iprot.readMessageEnd()
6784 
    result = markOrderAsLostInTransit_result()
6785 
    try:
6786 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6787 
    except TransactionServiceException, ex:
6788 
      result.ex = ex
6789 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6790 
    result.write(oprot)
6791 
    oprot.writeMessageEnd()
6792 
    oprot.trans.flush()
6793 
 
4386 anupam.sin 6794 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6795 
    args = getOrderForAwb_args()
6796 
    args.read(iprot)
6797 
    iprot.readMessageEnd()
6798 
    result = getOrderForAwb_result()
6799 
    try:
6800 
      result.success = self._handler.getOrderForAwb(args.awb)
6801 
    except TransactionServiceException, ex:
6802 
      result.ex = ex
6803 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6804 
    result.write(oprot)
6805 
    oprot.writeMessageEnd()
6806 
    oprot.trans.flush()
4369 rajveer 6807 
 
4506 phani.kuma 6808 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6809 
    args = getOrdersForProviderForStatus_args()
6810 
    args.read(iprot)
6811 
    iprot.readMessageEnd()
6812 
    result = getOrdersForProviderForStatus_result()
6813 
    try:
4910 phani.kuma 6814 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6815 
    except TransactionServiceException, ex:
6816 
      result.ex = ex
6817 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6818 
    result.write(oprot)
6819 
    oprot.writeMessageEnd()
6820 
    oprot.trans.flush()
4386 anupam.sin 6821 
 
4600 varun.gupt 6822 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6823 
    args = getBilledOrdersForVendor_args()
6824 
    args.read(iprot)
6825 
    iprot.readMessageEnd()
6826 
    result = getBilledOrdersForVendor_result()
6827 
    try:
6828 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6829 
    except TransactionServiceException, ex:
6830 
      result.ex = ex
6831 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6832 
    result.write(oprot)
6833 
    oprot.writeMessageEnd()
6834 
    oprot.trans.flush()
4506 phani.kuma 6835 
 
4607 rajveer 6836 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6837 
    args = getSlippedSippingDateOrders_args()
6838 
    args.read(iprot)
6839 
    iprot.readMessageEnd()
6840 
    result = getSlippedSippingDateOrders_result()
6841 
    try:
6842 
      result.success = self._handler.getSlippedSippingDateOrders()
6843 
    except TransactionServiceException, ex:
6844 
      result.ex = ex
6845 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6846 
    result.write(oprot)
6847 
    oprot.writeMessageEnd()
6848 
    oprot.trans.flush()
6849 
 
4709 rajveer 6850 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6851 
    args = getCancelledOrders_args()
6852 
    args.read(iprot)
6853 
    iprot.readMessageEnd()
6854 
    result = getCancelledOrders_result()
6855 
    try:
6856 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6857 
    except TransactionServiceException, ex:
6858 
      result.ex = ex
6859 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6860 
    result.write(oprot)
6861 
    oprot.writeMessageEnd()
6862 
    oprot.trans.flush()
6863 
 
4600 varun.gupt 6864 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6865 
    args = saveBluedartSettlements_args()
6866 
    args.read(iprot)
6867 
    iprot.readMessageEnd()
6868 
    result = saveBluedartSettlements_result()
6869 
    try:
6870 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6871 
    except TransactionServiceException, ex:
6872 
      result.ex = ex
6873 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6874 
    result.write(oprot)
6875 
    oprot.writeMessageEnd()
6876 
    oprot.trans.flush()
6877 
 
6878 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6879 
    args = savePaymentSettlements_args()
6880 
    args.read(iprot)
6881 
    iprot.readMessageEnd()
6882 
    result = savePaymentSettlements_result()
6883 
    try:
4905 varun.gupt 6884 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6885 
    except TransactionServiceException, ex:
6886 
      result.ex = ex
6887 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6888 
    result.write(oprot)
6889 
    oprot.writeMessageEnd()
6890 
    oprot.trans.flush()
6891 
 
6892 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6893 
    args = saveEBSSettlementSummary_args()
6894 
    args.read(iprot)
6895 
    iprot.readMessageEnd()
6896 
    result = saveEBSSettlementSummary_result()
6897 
    try:
6898 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6899 
    except TransactionServiceException, ex:
6900 
      result.ex = ex
6901 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6902 
    result.write(oprot)
6903 
    oprot.writeMessageEnd()
6904 
    oprot.trans.flush()
6905 
 
5386 phani.kuma 6906 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6907 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6908 
    args.read(iprot)
6909 
    iprot.readMessageEnd()
5386 phani.kuma 6910 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6911 
    try:
5386 phani.kuma 6912 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6913 
    except TransactionServiceException, ex:
6914 
      result.ex = ex
5386 phani.kuma 6915 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6916 
    result.write(oprot)
6917 
    oprot.writeMessageEnd()
6918 
    oprot.trans.flush()
6919 
 
5386 phani.kuma 6920 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6921 
    args = getSettlementForCod_args()
6922 
    args.read(iprot)
6923 
    iprot.readMessageEnd()
6924 
    result = getSettlementForCod_result()
6925 
    try:
6926 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6927 
    except TransactionServiceException, ex:
6928 
      result.ex = ex
6929 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6930 
    result.write(oprot)
6931 
    oprot.writeMessageEnd()
6932 
    oprot.trans.flush()
6933 
 
4600 varun.gupt 6934 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6935 
    args = getEBSSettlementSummaries_args()
6936 
    args.read(iprot)
6937 
    iprot.readMessageEnd()
6938 
    result = getEBSSettlementSummaries_result()
6939 
    try:
6940 
      result.success = self._handler.getEBSSettlementSummaries()
6941 
    except TransactionServiceException, ex:
6942 
      result.ex = ex
6943 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6944 
    result.write(oprot)
6945 
    oprot.writeMessageEnd()
6946 
    oprot.trans.flush()
6947 
 
6948 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6949 
    args = markEBSSettlementUploaded_args()
6950 
    args.read(iprot)
6951 
    iprot.readMessageEnd()
6952 
    result = markEBSSettlementUploaded_result()
6953 
    try:
6954 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6955 
    except TransactionServiceException, ex:
6956 
      result.ex = ex
6957 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6958 
    result.write(oprot)
6959 
    oprot.writeMessageEnd()
6960 
    oprot.trans.flush()
6961 
 
6962 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6963 
    args = getEBSSettlementDate_args()
6964 
    args.read(iprot)
6965 
    iprot.readMessageEnd()
6966 
    result = getEBSSettlementDate_result()
6967 
    try:
6968 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6969 
    except TransactionServiceException, ex:
6970 
      result.ex = ex
6971 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6972 
    result.write(oprot)
6973 
    oprot.writeMessageEnd()
6974 
    oprot.trans.flush()
6975 
 
4715 varun.gupt 6976 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6977 
    args = getSettlementsByDate_args()
6978 
    args.read(iprot)
6979 
    iprot.readMessageEnd()
6980 
    result = getSettlementsByDate_result()
6981 
    try:
6982 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6983 
    except TransactionServiceException, ex:
6984 
      result.ex = ex
6985 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6986 
    result.write(oprot)
6987 
    oprot.writeMessageEnd()
6988 
    oprot.trans.flush()
4600 varun.gupt 6989 
 
4715 varun.gupt 6990 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6991 
    args = getReshippedOrderIds_args()
6992 
    args.read(iprot)
6993 
    iprot.readMessageEnd()
6994 
    result = getReshippedOrderIds_result()
6995 
    try:
6996 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6997 
    except TransactionServiceException, ex:
6998 
      result.ex = ex
6999 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7000 
    result.write(oprot)
7001 
    oprot.writeMessageEnd()
7002 
    oprot.trans.flush()
7003 
 
5481 phani.kuma 7004 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7005 
    args = getBilledOrders_args()
4875 varun.gupt 7006 
    args.read(iprot)
7007 
    iprot.readMessageEnd()
5481 phani.kuma 7008 
    result = getBilledOrders_result()
4875 varun.gupt 7009 
    try:
5481 phani.kuma 7010 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7011 
    except TransactionServiceException, ex:
7012 
      result.ex = ex
5481 phani.kuma 7013 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7014 
    result.write(oprot)
7015 
    oprot.writeMessageEnd()
7016 
    oprot.trans.flush()
4757 mandeep.dh 7017 
 
5031 varun.gupt 7018 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7019 
    args = getStatusDistributionOfOrders_args()
7020 
    args.read(iprot)
7021 
    iprot.readMessageEnd()
7022 
    result = getStatusDistributionOfOrders_result()
7023 
    try:
7024 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7025 
    except TransactionServiceException, ex:
7026 
      result.ex = ex
7027 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7028 
    result.write(oprot)
7029 
    oprot.writeMessageEnd()
7030 
    oprot.trans.flush()
4875 varun.gupt 7031 
 
5067 varun.gupt 7032 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7033 
    args = getOrderIdsForStatus_args()
7034 
    args.read(iprot)
7035 
    iprot.readMessageEnd()
7036 
    result = getOrderIdsForStatus_result()
7037 
    try:
7038 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7039 
    except TransactionServiceException, ex:
7040 
      result.ex = ex
7041 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7042 
    result.write(oprot)
7043 
    oprot.writeMessageEnd()
7044 
    oprot.trans.flush()
5031 varun.gupt 7045 
 
5348 anupam.sin 7046 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7047 
    args = updateCODAgent_args()
7048 
    args.read(iprot)
7049 
    iprot.readMessageEnd()
7050 
    result = updateCODAgent_result()
7051 
    try:
7052 
      self._handler.updateCODAgent(args.agent, args.orderId)
7053 
    except TransactionServiceException, ex:
7054 
      result.ex = ex
7055 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7056 
    result.write(oprot)
7057 
    oprot.writeMessageEnd()
7058 
    oprot.trans.flush()
7059 
 
5099 varun.gupt 7060 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7061 
    args = updateOrderAsPaidToVendor_args()
7062 
    args.read(iprot)
7063 
    iprot.readMessageEnd()
7064 
    result = updateOrderAsPaidToVendor_result()
7065 
    try:
7066 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7067 
    except TransactionServiceException, ex:
7068 
      result.ex = ex
7069 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7070 
    result.write(oprot)
7071 
    oprot.writeMessageEnd()
7072 
    oprot.trans.flush()
5067 varun.gupt 7073 
 
5386 phani.kuma 7074 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7075 
    args = updateOrderOnlyAsPaidToVendor_args()
7076 
    args.read(iprot)
7077 
    iprot.readMessageEnd()
7078 
    result = updateOrderOnlyAsPaidToVendor_result()
7079 
    try:
7080 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7081 
    except TransactionServiceException, ex:
7082 
      result.ex = ex
7083 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7084 
    result.write(oprot)
7085 
    oprot.writeMessageEnd()
7086 
    oprot.trans.flush()
7087 
 
5208 varun.gupt 7088 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7089 
    args = getRefundedOrdersMarkedPaid_args()
7090 
    args.read(iprot)
7091 
    iprot.readMessageEnd()
7092 
    result = getRefundedOrdersMarkedPaid_result()
7093 
    try:
7094 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7095 
    except TransactionServiceException, ex:
7096 
      result.ex = ex
7097 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7098 
    result.write(oprot)
7099 
    oprot.writeMessageEnd()
7100 
    oprot.trans.flush()
5099 varun.gupt 7101 
 
5447 anupam.sin 7102 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7103 
    args = getAllVerificationAgents_args()
7104 
    args.read(iprot)
7105 
    iprot.readMessageEnd()
7106 
    result = getAllVerificationAgents_result()
7107 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7108 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7109 
    result.write(oprot)
7110 
    oprot.writeMessageEnd()
7111 
    oprot.trans.flush()
5208 varun.gupt 7112 
 
5527 anupam.sin 7113 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7114 
    args = getAllAttributesForOrderId_args()
7115 
    args.read(iprot)
7116 
    iprot.readMessageEnd()
7117 
    result = getAllAttributesForOrderId_result()
7118 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7119 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7120 
    result.write(oprot)
7121 
    oprot.writeMessageEnd()
7122 
    oprot.trans.flush()
5447 anupam.sin 7123 
 
5527 anupam.sin 7124 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7125 
    args = setOrderAttributeForTransaction_args()
7126 
    args.read(iprot)
7127 
    iprot.readMessageEnd()
7128 
    result = setOrderAttributeForTransaction_result()
7129 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7130 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7131 
    result.write(oprot)
7132 
    oprot.writeMessageEnd()
7133 
    oprot.trans.flush()
7134 
 
5553 rajveer 7135 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7136 
    args = getReceivePendingOrders_args()
7137 
    args.read(iprot)
7138 
    iprot.readMessageEnd()
7139 
    result = getReceivePendingOrders_result()
7140 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7141 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7142 
    result.write(oprot)
7143 
    oprot.writeMessageEnd()
7144 
    oprot.trans.flush()
5527 anupam.sin 7145 
 
5553 rajveer 7146 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7147 
    args = getReceivedAtStoreOrders_args()
7148 
    args.read(iprot)
7149 
    iprot.readMessageEnd()
7150 
    result = getReceivedAtStoreOrders_result()
7151 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7152 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7153 
    result.write(oprot)
7154 
    oprot.writeMessageEnd()
7155 
    oprot.trans.flush()
7156 
 
7157 
 
94 ashish 7158 
# HELPER FUNCTIONS AND STRUCTURES
7159 
 
7160 
class createTransaction_args:
7161 
  """
7162 
  Attributes:
7163 
   - transaction
7164 
  """
7165 
 
7166 
  thrift_spec = (
7167 
    None, # 0
7168 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7169 
  )
7170 
 
7171 
  def __init__(self, transaction=None,):
7172 
    self.transaction = transaction
7173 
 
7174 
  def read(self, iprot):
7175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7177 
      return
7178 
    iprot.readStructBegin()
7179 
    while True:
7180 
      (fname, ftype, fid) = iprot.readFieldBegin()
7181 
      if ftype == TType.STOP:
7182 
        break
7183 
      if fid == 1:
7184 
        if ftype == TType.STRUCT:
7185 
          self.transaction = Transaction()
7186 
          self.transaction.read(iprot)
7187 
        else:
7188 
          iprot.skip(ftype)
7189 
      else:
7190 
        iprot.skip(ftype)
7191 
      iprot.readFieldEnd()
7192 
    iprot.readStructEnd()
7193 
 
7194 
  def write(self, oprot):
7195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7197 
      return
7198 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7199 
    if self.transaction is not None:
94 ashish 7200 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7201 
      self.transaction.write(oprot)
7202 
      oprot.writeFieldEnd()
7203 
    oprot.writeFieldStop()
7204 
    oprot.writeStructEnd()
7205 
 
3431 rajveer 7206 
  def validate(self):
7207 
    return
7208 
 
7209 
 
94 ashish 7210 
  def __repr__(self):
7211 
    L = ['%s=%r' % (key, value)
7212 
      for key, value in self.__dict__.iteritems()]
7213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7214 
 
7215 
  def __eq__(self, other):
7216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7217 
 
7218 
  def __ne__(self, other):
7219 
    return not (self == other)
7220 
 
7221 
class createTransaction_result:
7222 
  """
7223 
  Attributes:
132 ashish 7224 
   - success
94 ashish 7225 
   - ex
7226 
  """
7227 
 
7228 
  thrift_spec = (
132 ashish 7229 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7231 
  )
7232 
 
132 ashish 7233 
  def __init__(self, success=None, ex=None,):
7234 
    self.success = success
94 ashish 7235 
    self.ex = ex
7236 
 
7237 
  def read(self, iprot):
7238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7240 
      return
7241 
    iprot.readStructBegin()
7242 
    while True:
7243 
      (fname, ftype, fid) = iprot.readFieldBegin()
7244 
      if ftype == TType.STOP:
7245 
        break
132 ashish 7246 
      if fid == 0:
7247 
        if ftype == TType.I64:
7248 
          self.success = iprot.readI64();
7249 
        else:
7250 
          iprot.skip(ftype)
7251 
      elif fid == 1:
94 ashish 7252 
        if ftype == TType.STRUCT:
7253 
          self.ex = TransactionServiceException()
7254 
          self.ex.read(iprot)
7255 
        else:
7256 
          iprot.skip(ftype)
7257 
      else:
7258 
        iprot.skip(ftype)
7259 
      iprot.readFieldEnd()
7260 
    iprot.readStructEnd()
7261 
 
7262 
  def write(self, oprot):
7263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7265 
      return
7266 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7267 
    if self.success is not None:
132 ashish 7268 
      oprot.writeFieldBegin('success', TType.I64, 0)
7269 
      oprot.writeI64(self.success)
7270 
      oprot.writeFieldEnd()
3431 rajveer 7271 
    if self.ex is not None:
94 ashish 7272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7273 
      self.ex.write(oprot)
7274 
      oprot.writeFieldEnd()
7275 
    oprot.writeFieldStop()
7276 
    oprot.writeStructEnd()
7277 
 
3431 rajveer 7278 
  def validate(self):
7279 
    return
7280 
 
7281 
 
94 ashish 7282 
  def __repr__(self):
7283 
    L = ['%s=%r' % (key, value)
7284 
      for key, value in self.__dict__.iteritems()]
7285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7286 
 
7287 
  def __eq__(self, other):
7288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7289 
 
7290 
  def __ne__(self, other):
7291 
    return not (self == other)
7292 
 
7293 
class getTransaction_args:
7294 
  """
7295 
  Attributes:
7296 
   - id
7297 
  """
7298 
 
7299 
  thrift_spec = (
7300 
    None, # 0
7301 
    (1, TType.I64, 'id', None, None, ), # 1
7302 
  )
7303 
 
7304 
  def __init__(self, id=None,):
7305 
    self.id = id
7306 
 
7307 
  def read(self, iprot):
7308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7310 
      return
7311 
    iprot.readStructBegin()
7312 
    while True:
7313 
      (fname, ftype, fid) = iprot.readFieldBegin()
7314 
      if ftype == TType.STOP:
7315 
        break
7316 
      if fid == 1:
7317 
        if ftype == TType.I64:
7318 
          self.id = iprot.readI64();
7319 
        else:
7320 
          iprot.skip(ftype)
7321 
      else:
7322 
        iprot.skip(ftype)
7323 
      iprot.readFieldEnd()
7324 
    iprot.readStructEnd()
7325 
 
7326 
  def write(self, oprot):
7327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7329 
      return
7330 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7331 
    if self.id is not None:
94 ashish 7332 
      oprot.writeFieldBegin('id', TType.I64, 1)
7333 
      oprot.writeI64(self.id)
7334 
      oprot.writeFieldEnd()
7335 
    oprot.writeFieldStop()
7336 
    oprot.writeStructEnd()
7337 
 
3431 rajveer 7338 
  def validate(self):
7339 
    return
7340 
 
7341 
 
94 ashish 7342 
  def __repr__(self):
7343 
    L = ['%s=%r' % (key, value)
7344 
      for key, value in self.__dict__.iteritems()]
7345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7346 
 
7347 
  def __eq__(self, other):
7348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7349 
 
7350 
  def __ne__(self, other):
7351 
    return not (self == other)
7352 
 
7353 
class getTransaction_result:
7354 
  """
7355 
  Attributes:
7356 
   - success
7357 
   - ex
7358 
  """
7359 
 
7360 
  thrift_spec = (
7361 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7363 
  )
7364 
 
7365 
  def __init__(self, success=None, ex=None,):
7366 
    self.success = success
7367 
    self.ex = ex
7368 
 
7369 
  def read(self, iprot):
7370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7372 
      return
7373 
    iprot.readStructBegin()
7374 
    while True:
7375 
      (fname, ftype, fid) = iprot.readFieldBegin()
7376 
      if ftype == TType.STOP:
7377 
        break
7378 
      if fid == 0:
7379 
        if ftype == TType.STRUCT:
7380 
          self.success = Transaction()
7381 
          self.success.read(iprot)
7382 
        else:
7383 
          iprot.skip(ftype)
7384 
      elif fid == 1:
7385 
        if ftype == TType.STRUCT:
7386 
          self.ex = TransactionServiceException()
7387 
          self.ex.read(iprot)
7388 
        else:
7389 
          iprot.skip(ftype)
7390 
      else:
7391 
        iprot.skip(ftype)
7392 
      iprot.readFieldEnd()
7393 
    iprot.readStructEnd()
7394 
 
7395 
  def write(self, oprot):
7396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7398 
      return
7399 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7400 
    if self.success is not None:
94 ashish 7401 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7402 
      self.success.write(oprot)
7403 
      oprot.writeFieldEnd()
3431 rajveer 7404 
    if self.ex is not None:
94 ashish 7405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7406 
      self.ex.write(oprot)
7407 
      oprot.writeFieldEnd()
7408 
    oprot.writeFieldStop()
7409 
    oprot.writeStructEnd()
7410 
 
3431 rajveer 7411 
  def validate(self):
7412 
    return
7413 
 
7414 
 
94 ashish 7415 
  def __repr__(self):
7416 
    L = ['%s=%r' % (key, value)
7417 
      for key, value in self.__dict__.iteritems()]
7418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7419 
 
7420 
  def __eq__(self, other):
7421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7422 
 
7423 
  def __ne__(self, other):
7424 
    return not (self == other)
7425 
 
7426 
class getTransactionsForCustomer_args:
7427 
  """
7428 
  Attributes:
7429 
   - customerId
7430 
   - from_date
7431 
   - to_date
7432 
   - status
7433 
  """
7434 
 
7435 
  thrift_spec = (
7436 
    None, # 0
7437 
    (1, TType.I64, 'customerId', None, None, ), # 1
7438 
    (2, TType.I64, 'from_date', None, None, ), # 2
7439 
    (3, TType.I64, 'to_date', None, None, ), # 3
7440 
    (4, TType.I32, 'status', None, None, ), # 4
7441 
  )
7442 
 
7443 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7444 
    self.customerId = customerId
7445 
    self.from_date = from_date
7446 
    self.to_date = to_date
7447 
    self.status = status
7448 
 
7449 
  def read(self, iprot):
7450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7452 
      return
7453 
    iprot.readStructBegin()
7454 
    while True:
7455 
      (fname, ftype, fid) = iprot.readFieldBegin()
7456 
      if ftype == TType.STOP:
7457 
        break
7458 
      if fid == 1:
7459 
        if ftype == TType.I64:
7460 
          self.customerId = iprot.readI64();
7461 
        else:
7462 
          iprot.skip(ftype)
7463 
      elif fid == 2:
7464 
        if ftype == TType.I64:
7465 
          self.from_date = iprot.readI64();
7466 
        else:
7467 
          iprot.skip(ftype)
7468 
      elif fid == 3:
7469 
        if ftype == TType.I64:
7470 
          self.to_date = iprot.readI64();
7471 
        else:
7472 
          iprot.skip(ftype)
7473 
      elif fid == 4:
7474 
        if ftype == TType.I32:
7475 
          self.status = iprot.readI32();
7476 
        else:
7477 
          iprot.skip(ftype)
7478 
      else:
7479 
        iprot.skip(ftype)
7480 
      iprot.readFieldEnd()
7481 
    iprot.readStructEnd()
7482 
 
7483 
  def write(self, oprot):
7484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7486 
      return
7487 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7488 
    if self.customerId is not None:
94 ashish 7489 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7490 
      oprot.writeI64(self.customerId)
7491 
      oprot.writeFieldEnd()
3431 rajveer 7492 
    if self.from_date is not None:
94 ashish 7493 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7494 
      oprot.writeI64(self.from_date)
7495 
      oprot.writeFieldEnd()
3431 rajveer 7496 
    if self.to_date is not None:
94 ashish 7497 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7498 
      oprot.writeI64(self.to_date)
7499 
      oprot.writeFieldEnd()
3431 rajveer 7500 
    if self.status is not None:
94 ashish 7501 
      oprot.writeFieldBegin('status', TType.I32, 4)
7502 
      oprot.writeI32(self.status)
7503 
      oprot.writeFieldEnd()
7504 
    oprot.writeFieldStop()
7505 
    oprot.writeStructEnd()
7506 
 
3431 rajveer 7507 
  def validate(self):
7508 
    return
7509 
 
7510 
 
94 ashish 7511 
  def __repr__(self):
7512 
    L = ['%s=%r' % (key, value)
7513 
      for key, value in self.__dict__.iteritems()]
7514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7515 
 
7516 
  def __eq__(self, other):
7517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7518 
 
7519 
  def __ne__(self, other):
7520 
    return not (self == other)
7521 
 
7522 
class getTransactionsForCustomer_result:
7523 
  """
7524 
  Attributes:
7525 
   - success
7526 
   - ex
7527 
  """
7528 
 
7529 
  thrift_spec = (
7530 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7532 
  )
7533 
 
7534 
  def __init__(self, success=None, ex=None,):
7535 
    self.success = success
7536 
    self.ex = ex
7537 
 
7538 
  def read(self, iprot):
7539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7541 
      return
7542 
    iprot.readStructBegin()
7543 
    while True:
7544 
      (fname, ftype, fid) = iprot.readFieldBegin()
7545 
      if ftype == TType.STOP:
7546 
        break
7547 
      if fid == 0:
7548 
        if ftype == TType.LIST:
7549 
          self.success = []
5031 varun.gupt 7550 
          (_etype66, _size63) = iprot.readListBegin()
7551 
          for _i67 in xrange(_size63):
7552 
            _elem68 = Transaction()
7553 
            _elem68.read(iprot)
7554 
            self.success.append(_elem68)
94 ashish 7555 
          iprot.readListEnd()
7556 
        else:
7557 
          iprot.skip(ftype)
7558 
      elif fid == 1:
7559 
        if ftype == TType.STRUCT:
7560 
          self.ex = TransactionServiceException()
7561 
          self.ex.read(iprot)
7562 
        else:
7563 
          iprot.skip(ftype)
7564 
      else:
7565 
        iprot.skip(ftype)
7566 
      iprot.readFieldEnd()
7567 
    iprot.readStructEnd()
7568 
 
7569 
  def write(self, oprot):
7570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7572 
      return
7573 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7574 
    if self.success is not None:
94 ashish 7575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7576 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7577 
      for iter69 in self.success:
7578 
        iter69.write(oprot)
94 ashish 7579 
      oprot.writeListEnd()
7580 
      oprot.writeFieldEnd()
3431 rajveer 7581 
    if self.ex is not None:
94 ashish 7582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7583 
      self.ex.write(oprot)
7584 
      oprot.writeFieldEnd()
7585 
    oprot.writeFieldStop()
7586 
    oprot.writeStructEnd()
7587 
 
3431 rajveer 7588 
  def validate(self):
7589 
    return
7590 
 
7591 
 
94 ashish 7592 
  def __repr__(self):
7593 
    L = ['%s=%r' % (key, value)
7594 
      for key, value in self.__dict__.iteritems()]
7595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7596 
 
7597 
  def __eq__(self, other):
7598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7599 
 
7600 
  def __ne__(self, other):
7601 
    return not (self == other)
7602 
 
132 ashish 7603 
class getTransactionsForShoppingCartId_args:
7604 
  """
7605 
  Attributes:
7606 
   - shoppingCartId
7607 
  """
7608 
 
7609 
  thrift_spec = (
7610 
    None, # 0
7611 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7612 
  )
7613 
 
7614 
  def __init__(self, shoppingCartId=None,):
7615 
    self.shoppingCartId = shoppingCartId
7616 
 
7617 
  def read(self, iprot):
7618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7620 
      return
7621 
    iprot.readStructBegin()
7622 
    while True:
7623 
      (fname, ftype, fid) = iprot.readFieldBegin()
7624 
      if ftype == TType.STOP:
7625 
        break
7626 
      if fid == 1:
7627 
        if ftype == TType.I64:
7628 
          self.shoppingCartId = iprot.readI64();
7629 
        else:
7630 
          iprot.skip(ftype)
7631 
      else:
7632 
        iprot.skip(ftype)
7633 
      iprot.readFieldEnd()
7634 
    iprot.readStructEnd()
7635 
 
7636 
  def write(self, oprot):
7637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7639 
      return
7640 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7641 
    if self.shoppingCartId is not None:
132 ashish 7642 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7643 
      oprot.writeI64(self.shoppingCartId)
7644 
      oprot.writeFieldEnd()
7645 
    oprot.writeFieldStop()
7646 
    oprot.writeStructEnd()
7647 
 
3431 rajveer 7648 
  def validate(self):
7649 
    return
7650 
 
7651 
 
132 ashish 7652 
  def __repr__(self):
7653 
    L = ['%s=%r' % (key, value)
7654 
      for key, value in self.__dict__.iteritems()]
7655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7656 
 
7657 
  def __eq__(self, other):
7658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7659 
 
7660 
  def __ne__(self, other):
7661 
    return not (self == other)
7662 
 
7663 
class getTransactionsForShoppingCartId_result:
7664 
  """
7665 
  Attributes:
7666 
   - success
7667 
   - ex
7668 
  """
7669 
 
7670 
  thrift_spec = (
7671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7673 
  )
7674 
 
7675 
  def __init__(self, success=None, ex=None,):
7676 
    self.success = success
7677 
    self.ex = ex
7678 
 
7679 
  def read(self, iprot):
7680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7682 
      return
7683 
    iprot.readStructBegin()
7684 
    while True:
7685 
      (fname, ftype, fid) = iprot.readFieldBegin()
7686 
      if ftype == TType.STOP:
7687 
        break
7688 
      if fid == 0:
7689 
        if ftype == TType.LIST:
7690 
          self.success = []
5031 varun.gupt 7691 
          (_etype73, _size70) = iprot.readListBegin()
7692 
          for _i74 in xrange(_size70):
7693 
            _elem75 = Transaction()
7694 
            _elem75.read(iprot)
7695 
            self.success.append(_elem75)
132 ashish 7696 
          iprot.readListEnd()
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      elif fid == 1:
7700 
        if ftype == TType.STRUCT:
7701 
          self.ex = TransactionServiceException()
7702 
          self.ex.read(iprot)
7703 
        else:
7704 
          iprot.skip(ftype)
7705 
      else:
7706 
        iprot.skip(ftype)
7707 
      iprot.readFieldEnd()
7708 
    iprot.readStructEnd()
7709 
 
7710 
  def write(self, oprot):
7711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7713 
      return
7714 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7715 
    if self.success is not None:
132 ashish 7716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7718 
      for iter76 in self.success:
7719 
        iter76.write(oprot)
132 ashish 7720 
      oprot.writeListEnd()
7721 
      oprot.writeFieldEnd()
3431 rajveer 7722 
    if self.ex is not None:
132 ashish 7723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7724 
      self.ex.write(oprot)
7725 
      oprot.writeFieldEnd()
7726 
    oprot.writeFieldStop()
7727 
    oprot.writeStructEnd()
7728 
 
3431 rajveer 7729 
  def validate(self):
7730 
    return
7731 
 
7732 
 
132 ashish 7733 
  def __repr__(self):
7734 
    L = ['%s=%r' % (key, value)
7735 
      for key, value in self.__dict__.iteritems()]
7736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7737 
 
7738 
  def __eq__(self, other):
7739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7740 
 
7741 
  def __ne__(self, other):
7742 
    return not (self == other)
7743 
 
94 ashish 7744 
class getTransactionStatus_args:
7745 
  """
7746 
  Attributes:
7747 
   - transactionId
7748 
  """
7749 
 
7750 
  thrift_spec = (
7751 
    None, # 0
7752 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7753 
  )
7754 
 
7755 
  def __init__(self, transactionId=None,):
7756 
    self.transactionId = transactionId
7757 
 
7758 
  def read(self, iprot):
7759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7761 
      return
7762 
    iprot.readStructBegin()
7763 
    while True:
7764 
      (fname, ftype, fid) = iprot.readFieldBegin()
7765 
      if ftype == TType.STOP:
7766 
        break
7767 
      if fid == 1:
7768 
        if ftype == TType.I64:
7769 
          self.transactionId = iprot.readI64();
7770 
        else:
7771 
          iprot.skip(ftype)
7772 
      else:
7773 
        iprot.skip(ftype)
7774 
      iprot.readFieldEnd()
7775 
    iprot.readStructEnd()
7776 
 
7777 
  def write(self, oprot):
7778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7780 
      return
7781 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7782 
    if self.transactionId is not None:
94 ashish 7783 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7784 
      oprot.writeI64(self.transactionId)
7785 
      oprot.writeFieldEnd()
7786 
    oprot.writeFieldStop()
7787 
    oprot.writeStructEnd()
7788 
 
3431 rajveer 7789 
  def validate(self):
7790 
    return
7791 
 
7792 
 
94 ashish 7793 
  def __repr__(self):
7794 
    L = ['%s=%r' % (key, value)
7795 
      for key, value in self.__dict__.iteritems()]
7796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7797 
 
7798 
  def __eq__(self, other):
7799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7800 
 
7801 
  def __ne__(self, other):
7802 
    return not (self == other)
7803 
 
7804 
class getTransactionStatus_result:
7805 
  """
7806 
  Attributes:
7807 
   - success
7808 
   - ex
7809 
  """
7810 
 
7811 
  thrift_spec = (
7812 
    (0, TType.I32, 'success', None, None, ), # 0
7813 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7814 
  )
7815 
 
7816 
  def __init__(self, success=None, ex=None,):
7817 
    self.success = success
7818 
    self.ex = ex
7819 
 
7820 
  def read(self, iprot):
7821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7823 
      return
7824 
    iprot.readStructBegin()
7825 
    while True:
7826 
      (fname, ftype, fid) = iprot.readFieldBegin()
7827 
      if ftype == TType.STOP:
7828 
        break
7829 
      if fid == 0:
7830 
        if ftype == TType.I32:
7831 
          self.success = iprot.readI32();
7832 
        else:
7833 
          iprot.skip(ftype)
7834 
      elif fid == 1:
7835 
        if ftype == TType.STRUCT:
7836 
          self.ex = TransactionServiceException()
7837 
          self.ex.read(iprot)
7838 
        else:
7839 
          iprot.skip(ftype)
7840 
      else:
7841 
        iprot.skip(ftype)
7842 
      iprot.readFieldEnd()
7843 
    iprot.readStructEnd()
7844 
 
7845 
  def write(self, oprot):
7846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7848 
      return
7849 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7850 
    if self.success is not None:
94 ashish 7851 
      oprot.writeFieldBegin('success', TType.I32, 0)
7852 
      oprot.writeI32(self.success)
7853 
      oprot.writeFieldEnd()
3431 rajveer 7854 
    if self.ex is not None:
94 ashish 7855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7856 
      self.ex.write(oprot)
7857 
      oprot.writeFieldEnd()
7858 
    oprot.writeFieldStop()
7859 
    oprot.writeStructEnd()
7860 
 
3431 rajveer 7861 
  def validate(self):
7862 
    return
7863 
 
7864 
 
94 ashish 7865 
  def __repr__(self):
7866 
    L = ['%s=%r' % (key, value)
7867 
      for key, value in self.__dict__.iteritems()]
7868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7869 
 
7870 
  def __eq__(self, other):
7871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7872 
 
7873 
  def __ne__(self, other):
7874 
    return not (self == other)
7875 
 
7876 
class changeTransactionStatus_args:
7877 
  """
7878 
  Attributes:
7879 
   - transactionId
7880 
   - status
7881 
   - description
5527 anupam.sin 7882 
   - pickUp
7883 
   - orderType
94 ashish 7884 
  """
7885 
 
7886 
  thrift_spec = (
7887 
    None, # 0
7888 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7889 
    (2, TType.I32, 'status', None, None, ), # 2
7890 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 7891 
    (4, TType.I64, 'pickUp', None, None, ), # 4
7892 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 7893 
  )
7894 
 
5527 anupam.sin 7895 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 7896 
    self.transactionId = transactionId
7897 
    self.status = status
7898 
    self.description = description
5527 anupam.sin 7899 
    self.pickUp = pickUp
7900 
    self.orderType = orderType
94 ashish 7901 
 
7902 
  def read(self, iprot):
7903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7905 
      return
7906 
    iprot.readStructBegin()
7907 
    while True:
7908 
      (fname, ftype, fid) = iprot.readFieldBegin()
7909 
      if ftype == TType.STOP:
7910 
        break
7911 
      if fid == 1:
7912 
        if ftype == TType.I64:
7913 
          self.transactionId = iprot.readI64();
7914 
        else:
7915 
          iprot.skip(ftype)
7916 
      elif fid == 2:
7917 
        if ftype == TType.I32:
7918 
          self.status = iprot.readI32();
7919 
        else:
7920 
          iprot.skip(ftype)
7921 
      elif fid == 3:
7922 
        if ftype == TType.STRING:
7923 
          self.description = iprot.readString();
7924 
        else:
7925 
          iprot.skip(ftype)
5387 rajveer 7926 
      elif fid == 4:
5527 anupam.sin 7927 
        if ftype == TType.I64:
7928 
          self.pickUp = iprot.readI64();
5387 rajveer 7929 
        else:
7930 
          iprot.skip(ftype)
5527 anupam.sin 7931 
      elif fid == 5:
7932 
        if ftype == TType.I32:
7933 
          self.orderType = iprot.readI32();
7934 
        else:
7935 
          iprot.skip(ftype)
94 ashish 7936 
      else:
7937 
        iprot.skip(ftype)
7938 
      iprot.readFieldEnd()
7939 
    iprot.readStructEnd()
7940 
 
7941 
  def write(self, oprot):
7942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7944 
      return
7945 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7946 
    if self.transactionId is not None:
94 ashish 7947 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7948 
      oprot.writeI64(self.transactionId)
7949 
      oprot.writeFieldEnd()
3431 rajveer 7950 
    if self.status is not None:
94 ashish 7951 
      oprot.writeFieldBegin('status', TType.I32, 2)
7952 
      oprot.writeI32(self.status)
7953 
      oprot.writeFieldEnd()
3431 rajveer 7954 
    if self.description is not None:
94 ashish 7955 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7956 
      oprot.writeString(self.description)
7957 
      oprot.writeFieldEnd()
5527 anupam.sin 7958 
    if self.pickUp is not None:
7959 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
7960 
      oprot.writeI64(self.pickUp)
5387 rajveer 7961 
      oprot.writeFieldEnd()
5527 anupam.sin 7962 
    if self.orderType is not None:
7963 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
7964 
      oprot.writeI32(self.orderType)
7965 
      oprot.writeFieldEnd()
94 ashish 7966 
    oprot.writeFieldStop()
7967 
    oprot.writeStructEnd()
7968 
 
3431 rajveer 7969 
  def validate(self):
7970 
    return
7971 
 
7972 
 
94 ashish 7973 
  def __repr__(self):
7974 
    L = ['%s=%r' % (key, value)
7975 
      for key, value in self.__dict__.iteritems()]
7976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7977 
 
7978 
  def __eq__(self, other):
7979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7980 
 
7981 
  def __ne__(self, other):
7982 
    return not (self == other)
7983 
 
7984 
class changeTransactionStatus_result:
7985 
  """
7986 
  Attributes:
7987 
   - success
7988 
   - ex
7989 
  """
7990 
 
7991 
  thrift_spec = (
7992 
    (0, TType.BOOL, 'success', None, None, ), # 0
7993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7994 
  )
7995 
 
7996 
  def __init__(self, success=None, ex=None,):
7997 
    self.success = success
7998 
    self.ex = ex
7999 
 
8000 
  def read(self, iprot):
8001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8003 
      return
8004 
    iprot.readStructBegin()
8005 
    while True:
8006 
      (fname, ftype, fid) = iprot.readFieldBegin()
8007 
      if ftype == TType.STOP:
8008 
        break
8009 
      if fid == 0:
8010 
        if ftype == TType.BOOL:
8011 
          self.success = iprot.readBool();
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      elif fid == 1:
8015 
        if ftype == TType.STRUCT:
8016 
          self.ex = TransactionServiceException()
8017 
          self.ex.read(iprot)
8018 
        else:
8019 
          iprot.skip(ftype)
8020 
      else:
8021 
        iprot.skip(ftype)
8022 
      iprot.readFieldEnd()
8023 
    iprot.readStructEnd()
8024 
 
8025 
  def write(self, oprot):
8026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8028 
      return
8029 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8030 
    if self.success is not None:
94 ashish 8031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8032 
      oprot.writeBool(self.success)
8033 
      oprot.writeFieldEnd()
3431 rajveer 8034 
    if self.ex is not None:
94 ashish 8035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8036 
      self.ex.write(oprot)
8037 
      oprot.writeFieldEnd()
8038 
    oprot.writeFieldStop()
8039 
    oprot.writeStructEnd()
8040 
 
3431 rajveer 8041 
  def validate(self):
8042 
    return
8043 
 
8044 
 
94 ashish 8045 
  def __repr__(self):
8046 
    L = ['%s=%r' % (key, value)
8047 
      for key, value in self.__dict__.iteritems()]
8048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8049 
 
8050 
  def __eq__(self, other):
8051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8052 
 
8053 
  def __ne__(self, other):
8054 
    return not (self == other)
8055 
 
1398 varun.gupt 8056 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8057 
  """
8058 
  Attributes:
8059 
   - transactionId
8060 
  """
8061 
 
8062 
  thrift_spec = (
8063 
    None, # 0
8064 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8065 
  )
8066 
 
8067 
  def __init__(self, transactionId=None,):
8068 
    self.transactionId = transactionId
8069 
 
8070 
  def read(self, iprot):
8071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8073 
      return
8074 
    iprot.readStructBegin()
8075 
    while True:
8076 
      (fname, ftype, fid) = iprot.readFieldBegin()
8077 
      if ftype == TType.STOP:
8078 
        break
8079 
      if fid == 1:
8080 
        if ftype == TType.I64:
8081 
          self.transactionId = iprot.readI64();
8082 
        else:
8083 
          iprot.skip(ftype)
8084 
      else:
8085 
        iprot.skip(ftype)
8086 
      iprot.readFieldEnd()
8087 
    iprot.readStructEnd()
8088 
 
8089 
  def write(self, oprot):
8090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8092 
      return
1398 varun.gupt 8093 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8094 
    if self.transactionId is not None:
1382 varun.gupt 8095 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8096 
      oprot.writeI64(self.transactionId)
8097 
      oprot.writeFieldEnd()
8098 
    oprot.writeFieldStop()
8099 
    oprot.writeStructEnd()
8100 
 
3431 rajveer 8101 
  def validate(self):
8102 
    return
8103 
 
8104 
 
1382 varun.gupt 8105 
  def __repr__(self):
8106 
    L = ['%s=%r' % (key, value)
8107 
      for key, value in self.__dict__.iteritems()]
8108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8109 
 
8110 
  def __eq__(self, other):
8111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8112 
 
8113 
  def __ne__(self, other):
8114 
    return not (self == other)
8115 
 
1398 varun.gupt 8116 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8117 
  """
8118 
  Attributes:
8119 
   - success
8120 
   - ex
8121 
  """
8122 
 
8123 
  thrift_spec = (
8124 
    (0, TType.BOOL, 'success', None, None, ), # 0
8125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8126 
  )
8127 
 
8128 
  def __init__(self, success=None, ex=None,):
8129 
    self.success = success
8130 
    self.ex = ex
8131 
 
8132 
  def read(self, iprot):
8133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8135 
      return
8136 
    iprot.readStructBegin()
8137 
    while True:
8138 
      (fname, ftype, fid) = iprot.readFieldBegin()
8139 
      if ftype == TType.STOP:
8140 
        break
8141 
      if fid == 0:
8142 
        if ftype == TType.BOOL:
8143 
          self.success = iprot.readBool();
8144 
        else:
8145 
          iprot.skip(ftype)
8146 
      elif fid == 1:
8147 
        if ftype == TType.STRUCT:
8148 
          self.ex = TransactionServiceException()
8149 
          self.ex.read(iprot)
8150 
        else:
8151 
          iprot.skip(ftype)
8152 
      else:
8153 
        iprot.skip(ftype)
8154 
      iprot.readFieldEnd()
8155 
    iprot.readStructEnd()
8156 
 
8157 
  def write(self, oprot):
8158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8160 
      return
1398 varun.gupt 8161 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8162 
    if self.success is not None:
1382 varun.gupt 8163 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8164 
      oprot.writeBool(self.success)
8165 
      oprot.writeFieldEnd()
3431 rajveer 8166 
    if self.ex is not None:
1382 varun.gupt 8167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8168 
      self.ex.write(oprot)
8169 
      oprot.writeFieldEnd()
8170 
    oprot.writeFieldStop()
8171 
    oprot.writeStructEnd()
8172 
 
3431 rajveer 8173 
  def validate(self):
8174 
    return
8175 
 
8176 
 
1382 varun.gupt 8177 
  def __repr__(self):
8178 
    L = ['%s=%r' % (key, value)
8179 
      for key, value in self.__dict__.iteritems()]
8180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8181 
 
8182 
  def __eq__(self, other):
8183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8184 
 
8185 
  def __ne__(self, other):
8186 
    return not (self == other)
8187 
 
483 rajveer 8188 
class getAllOrders_args:
94 ashish 8189 
  """
8190 
  Attributes:
4801 anupam.sin 8191 
   - statuses
483 rajveer 8192 
   - from_date
8193 
   - to_date
8194 
   - warehouse_id
94 ashish 8195 
  """
8196 
 
8197 
  thrift_spec = (
8198 
    None, # 0
4801 anupam.sin 8199 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8200 
    (2, TType.I64, 'from_date', None, None, ), # 2
8201 
    (3, TType.I64, 'to_date', None, None, ), # 3
8202 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8203 
  )
8204 
 
4801 anupam.sin 8205 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8206 
    self.statuses = statuses
483 rajveer 8207 
    self.from_date = from_date
8208 
    self.to_date = to_date
8209 
    self.warehouse_id = warehouse_id
94 ashish 8210 
 
8211 
  def read(self, iprot):
8212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8214 
      return
8215 
    iprot.readStructBegin()
8216 
    while True:
8217 
      (fname, ftype, fid) = iprot.readFieldBegin()
8218 
      if ftype == TType.STOP:
8219 
        break
8220 
      if fid == 1:
4801 anupam.sin 8221 
        if ftype == TType.LIST:
8222 
          self.statuses = []
5031 varun.gupt 8223 
          (_etype80, _size77) = iprot.readListBegin()
8224 
          for _i81 in xrange(_size77):
8225 
            _elem82 = iprot.readI32();
8226 
            self.statuses.append(_elem82)
4801 anupam.sin 8227 
          iprot.readListEnd()
94 ashish 8228 
        else:
8229 
          iprot.skip(ftype)
483 rajveer 8230 
      elif fid == 2:
8231 
        if ftype == TType.I64:
8232 
          self.from_date = iprot.readI64();
94 ashish 8233 
        else:
8234 
          iprot.skip(ftype)
483 rajveer 8235 
      elif fid == 3:
8236 
        if ftype == TType.I64:
8237 
          self.to_date = iprot.readI64();
94 ashish 8238 
        else:
8239 
          iprot.skip(ftype)
483 rajveer 8240 
      elif fid == 4:
94 ashish 8241 
        if ftype == TType.I64:
483 rajveer 8242 
          self.warehouse_id = iprot.readI64();
94 ashish 8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      else:
8246 
        iprot.skip(ftype)
8247 
      iprot.readFieldEnd()
8248 
    iprot.readStructEnd()
8249 
 
8250 
  def write(self, oprot):
8251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8253 
      return
483 rajveer 8254 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8255 
    if self.statuses is not None:
8256 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8257 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8258 
      for iter83 in self.statuses:
8259 
        oprot.writeI32(iter83)
4801 anupam.sin 8260 
      oprot.writeListEnd()
94 ashish 8261 
      oprot.writeFieldEnd()
3431 rajveer 8262 
    if self.from_date is not None:
483 rajveer 8263 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8264 
      oprot.writeI64(self.from_date)
94 ashish 8265 
      oprot.writeFieldEnd()
3431 rajveer 8266 
    if self.to_date is not None:
483 rajveer 8267 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8268 
      oprot.writeI64(self.to_date)
94 ashish 8269 
      oprot.writeFieldEnd()
3431 rajveer 8270 
    if self.warehouse_id is not None:
483 rajveer 8271 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8272 
      oprot.writeI64(self.warehouse_id)
94 ashish 8273 
      oprot.writeFieldEnd()
8274 
    oprot.writeFieldStop()
8275 
    oprot.writeStructEnd()
8276 
 
3431 rajveer 8277 
  def validate(self):
8278 
    return
8279 
 
8280 
 
94 ashish 8281 
  def __repr__(self):
8282 
    L = ['%s=%r' % (key, value)
8283 
      for key, value in self.__dict__.iteritems()]
8284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8285 
 
8286 
  def __eq__(self, other):
8287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8288 
 
8289 
  def __ne__(self, other):
8290 
    return not (self == other)
8291 
 
483 rajveer 8292 
class getAllOrders_result:
94 ashish 8293 
  """
8294 
  Attributes:
8295 
   - success
8296 
   - ex
8297 
  """
8298 
 
8299 
  thrift_spec = (
483 rajveer 8300 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8302 
  )
8303 
 
8304 
  def __init__(self, success=None, ex=None,):
8305 
    self.success = success
8306 
    self.ex = ex
8307 
 
8308 
  def read(self, iprot):
8309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8311 
      return
8312 
    iprot.readStructBegin()
8313 
    while True:
8314 
      (fname, ftype, fid) = iprot.readFieldBegin()
8315 
      if ftype == TType.STOP:
8316 
        break
8317 
      if fid == 0:
483 rajveer 8318 
        if ftype == TType.LIST:
8319 
          self.success = []
5031 varun.gupt 8320 
          (_etype87, _size84) = iprot.readListBegin()
8321 
          for _i88 in xrange(_size84):
8322 
            _elem89 = Order()
8323 
            _elem89.read(iprot)
8324 
            self.success.append(_elem89)
483 rajveer 8325 
          iprot.readListEnd()
94 ashish 8326 
        else:
8327 
          iprot.skip(ftype)
8328 
      elif fid == 1:
8329 
        if ftype == TType.STRUCT:
8330 
          self.ex = TransactionServiceException()
8331 
          self.ex.read(iprot)
8332 
        else:
8333 
          iprot.skip(ftype)
8334 
      else:
8335 
        iprot.skip(ftype)
8336 
      iprot.readFieldEnd()
8337 
    iprot.readStructEnd()
8338 
 
8339 
  def write(self, oprot):
8340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8342 
      return
483 rajveer 8343 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8344 
    if self.success is not None:
483 rajveer 8345 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8346 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8347 
      for iter90 in self.success:
8348 
        iter90.write(oprot)
483 rajveer 8349 
      oprot.writeListEnd()
94 ashish 8350 
      oprot.writeFieldEnd()
3431 rajveer 8351 
    if self.ex is not None:
94 ashish 8352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8353 
      self.ex.write(oprot)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
3431 rajveer 8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
94 ashish 8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
4133 chandransh 8373 
class getOrdersInBatch_args:
8374 
  """
8375 
  Attributes:
8376 
   - statuses
8377 
   - offset
8378 
   - limit
8379 
   - warehouse_id
8380 
  """
8381 
 
8382 
  thrift_spec = (
8383 
    None, # 0
8384 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8385 
    (2, TType.I64, 'offset', None, None, ), # 2
8386 
    (3, TType.I64, 'limit', None, None, ), # 3
8387 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8388 
  )
8389 
 
8390 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8391 
    self.statuses = statuses
8392 
    self.offset = offset
8393 
    self.limit = limit
8394 
    self.warehouse_id = warehouse_id
8395 
 
8396 
  def read(self, iprot):
8397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8399 
      return
8400 
    iprot.readStructBegin()
8401 
    while True:
8402 
      (fname, ftype, fid) = iprot.readFieldBegin()
8403 
      if ftype == TType.STOP:
8404 
        break
8405 
      if fid == 1:
8406 
        if ftype == TType.LIST:
8407 
          self.statuses = []
5031 varun.gupt 8408 
          (_etype94, _size91) = iprot.readListBegin()
8409 
          for _i95 in xrange(_size91):
8410 
            _elem96 = iprot.readI32();
8411 
            self.statuses.append(_elem96)
4133 chandransh 8412 
          iprot.readListEnd()
8413 
        else:
8414 
          iprot.skip(ftype)
8415 
      elif fid == 2:
8416 
        if ftype == TType.I64:
8417 
          self.offset = iprot.readI64();
8418 
        else:
8419 
          iprot.skip(ftype)
8420 
      elif fid == 3:
8421 
        if ftype == TType.I64:
8422 
          self.limit = iprot.readI64();
8423 
        else:
8424 
          iprot.skip(ftype)
8425 
      elif fid == 4:
8426 
        if ftype == TType.I64:
8427 
          self.warehouse_id = iprot.readI64();
8428 
        else:
8429 
          iprot.skip(ftype)
8430 
      else:
8431 
        iprot.skip(ftype)
8432 
      iprot.readFieldEnd()
8433 
    iprot.readStructEnd()
8434 
 
8435 
  def write(self, oprot):
8436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8438 
      return
8439 
    oprot.writeStructBegin('getOrdersInBatch_args')
8440 
    if self.statuses is not None:
8441 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8442 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8443 
      for iter97 in self.statuses:
8444 
        oprot.writeI32(iter97)
4133 chandransh 8445 
      oprot.writeListEnd()
8446 
      oprot.writeFieldEnd()
8447 
    if self.offset is not None:
8448 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8449 
      oprot.writeI64(self.offset)
8450 
      oprot.writeFieldEnd()
8451 
    if self.limit is not None:
8452 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8453 
      oprot.writeI64(self.limit)
8454 
      oprot.writeFieldEnd()
8455 
    if self.warehouse_id is not None:
8456 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8457 
      oprot.writeI64(self.warehouse_id)
8458 
      oprot.writeFieldEnd()
8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
8477 
class getOrdersInBatch_result:
8478 
  """
8479 
  Attributes:
8480 
   - success
8481 
   - ex
8482 
  """
8483 
 
8484 
  thrift_spec = (
8485 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8487 
  )
8488 
 
8489 
  def __init__(self, success=None, ex=None,):
8490 
    self.success = success
8491 
    self.ex = ex
8492 
 
8493 
  def read(self, iprot):
8494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8496 
      return
8497 
    iprot.readStructBegin()
8498 
    while True:
8499 
      (fname, ftype, fid) = iprot.readFieldBegin()
8500 
      if ftype == TType.STOP:
8501 
        break
8502 
      if fid == 0:
8503 
        if ftype == TType.LIST:
8504 
          self.success = []
5031 varun.gupt 8505 
          (_etype101, _size98) = iprot.readListBegin()
8506 
          for _i102 in xrange(_size98):
8507 
            _elem103 = Order()
8508 
            _elem103.read(iprot)
8509 
            self.success.append(_elem103)
4133 chandransh 8510 
          iprot.readListEnd()
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.ex = TransactionServiceException()
8516 
          self.ex.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
8528 
    oprot.writeStructBegin('getOrdersInBatch_result')
8529 
    if self.success is not None:
8530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8532 
      for iter104 in self.success:
8533 
        iter104.write(oprot)
4133 chandransh 8534 
      oprot.writeListEnd()
8535 
      oprot.writeFieldEnd()
8536 
    if self.ex is not None:
8537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8538 
      self.ex.write(oprot)
8539 
      oprot.writeFieldEnd()
8540 
    oprot.writeFieldStop()
8541 
    oprot.writeStructEnd()
8542 
 
8543 
  def validate(self):
8544 
    return
8545 
 
8546 
 
8547 
  def __repr__(self):
8548 
    L = ['%s=%r' % (key, value)
8549 
      for key, value in self.__dict__.iteritems()]
8550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8551 
 
8552 
  def __eq__(self, other):
8553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8554 
 
8555 
  def __ne__(self, other):
8556 
    return not (self == other)
8557 
 
8558 
class getOrderCount_args:
8559 
  """
8560 
  Attributes:
8561 
   - statuses
8562 
   - warehouseId
8563 
  """
8564 
 
8565 
  thrift_spec = (
8566 
    None, # 0
8567 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8568 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8569 
  )
8570 
 
8571 
  def __init__(self, statuses=None, warehouseId=None,):
8572 
    self.statuses = statuses
8573 
    self.warehouseId = warehouseId
8574 
 
8575 
  def read(self, iprot):
8576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8578 
      return
8579 
    iprot.readStructBegin()
8580 
    while True:
8581 
      (fname, ftype, fid) = iprot.readFieldBegin()
8582 
      if ftype == TType.STOP:
8583 
        break
8584 
      if fid == 1:
8585 
        if ftype == TType.LIST:
8586 
          self.statuses = []
5031 varun.gupt 8587 
          (_etype108, _size105) = iprot.readListBegin()
8588 
          for _i109 in xrange(_size105):
8589 
            _elem110 = iprot.readI32();
8590 
            self.statuses.append(_elem110)
4133 chandransh 8591 
          iprot.readListEnd()
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      elif fid == 2:
8595 
        if ftype == TType.I64:
8596 
          self.warehouseId = iprot.readI64();
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      else:
8600 
        iprot.skip(ftype)
8601 
      iprot.readFieldEnd()
8602 
    iprot.readStructEnd()
8603 
 
8604 
  def write(self, oprot):
8605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8607 
      return
8608 
    oprot.writeStructBegin('getOrderCount_args')
8609 
    if self.statuses is not None:
8610 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8611 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8612 
      for iter111 in self.statuses:
8613 
        oprot.writeI32(iter111)
4133 chandransh 8614 
      oprot.writeListEnd()
8615 
      oprot.writeFieldEnd()
8616 
    if self.warehouseId is not None:
8617 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8618 
      oprot.writeI64(self.warehouseId)
8619 
      oprot.writeFieldEnd()
8620 
    oprot.writeFieldStop()
8621 
    oprot.writeStructEnd()
8622 
 
8623 
  def validate(self):
8624 
    return
8625 
 
8626 
 
8627 
  def __repr__(self):
8628 
    L = ['%s=%r' % (key, value)
8629 
      for key, value in self.__dict__.iteritems()]
8630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8631 
 
8632 
  def __eq__(self, other):
8633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8634 
 
8635 
  def __ne__(self, other):
8636 
    return not (self == other)
8637 
 
8638 
class getOrderCount_result:
8639 
  """
8640 
  Attributes:
8641 
   - success
8642 
   - ex
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    (0, TType.I32, 'success', None, None, ), # 0
8647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, success=None, ex=None,):
8651 
    self.success = success
8652 
    self.ex = ex
8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 0:
8664 
        if ftype == TType.I32:
8665 
          self.success = iprot.readI32();
8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      elif fid == 1:
8669 
        if ftype == TType.STRUCT:
8670 
          self.ex = TransactionServiceException()
8671 
          self.ex.read(iprot)
8672 
        else:
8673 
          iprot.skip(ftype)
8674 
      else:
8675 
        iprot.skip(ftype)
8676 
      iprot.readFieldEnd()
8677 
    iprot.readStructEnd()
8678 
 
8679 
  def write(self, oprot):
8680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8682 
      return
8683 
    oprot.writeStructBegin('getOrderCount_result')
8684 
    if self.success is not None:
8685 
      oprot.writeFieldBegin('success', TType.I32, 0)
8686 
      oprot.writeI32(self.success)
8687 
      oprot.writeFieldEnd()
8688 
    if self.ex is not None:
8689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8690 
      self.ex.write(oprot)
8691 
      oprot.writeFieldEnd()
8692 
    oprot.writeFieldStop()
8693 
    oprot.writeStructEnd()
8694 
 
8695 
  def validate(self):
8696 
    return
8697 
 
8698 
 
8699 
  def __repr__(self):
8700 
    L = ['%s=%r' % (key, value)
8701 
      for key, value in self.__dict__.iteritems()]
8702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8703 
 
8704 
  def __eq__(self, other):
8705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8706 
 
8707 
  def __ne__(self, other):
8708 
    return not (self == other)
8709 
 
999 varun.gupt 8710 
class getOrdersByBillingDate_args:
8711 
  """
8712 
  Attributes:
8713 
   - status
8714 
   - start_billing_date
8715 
   - end_billing_date
8716 
   - warehouse_id
8717 
  """
8718 
 
8719 
  thrift_spec = (
8720 
    None, # 0
8721 
    (1, TType.I32, 'status', None, None, ), # 1
8722 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8723 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8724 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8725 
  )
8726 
 
8727 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8728 
    self.status = status
8729 
    self.start_billing_date = start_billing_date
8730 
    self.end_billing_date = end_billing_date
8731 
    self.warehouse_id = warehouse_id
8732 
 
8733 
  def read(self, iprot):
8734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8736 
      return
8737 
    iprot.readStructBegin()
8738 
    while True:
8739 
      (fname, ftype, fid) = iprot.readFieldBegin()
8740 
      if ftype == TType.STOP:
8741 
        break
8742 
      if fid == 1:
8743 
        if ftype == TType.I32:
8744 
          self.status = iprot.readI32();
8745 
        else:
8746 
          iprot.skip(ftype)
8747 
      elif fid == 2:
8748 
        if ftype == TType.I64:
8749 
          self.start_billing_date = iprot.readI64();
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      elif fid == 3:
8753 
        if ftype == TType.I64:
8754 
          self.end_billing_date = iprot.readI64();
8755 
        else:
8756 
          iprot.skip(ftype)
8757 
      elif fid == 4:
8758 
        if ftype == TType.I64:
8759 
          self.warehouse_id = iprot.readI64();
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      else:
8763 
        iprot.skip(ftype)
8764 
      iprot.readFieldEnd()
8765 
    iprot.readStructEnd()
8766 
 
8767 
  def write(self, oprot):
8768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8770 
      return
8771 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8772 
    if self.status is not None:
999 varun.gupt 8773 
      oprot.writeFieldBegin('status', TType.I32, 1)
8774 
      oprot.writeI32(self.status)
8775 
      oprot.writeFieldEnd()
3431 rajveer 8776 
    if self.start_billing_date is not None:
999 varun.gupt 8777 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8778 
      oprot.writeI64(self.start_billing_date)
8779 
      oprot.writeFieldEnd()
3431 rajveer 8780 
    if self.end_billing_date is not None:
999 varun.gupt 8781 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8782 
      oprot.writeI64(self.end_billing_date)
8783 
      oprot.writeFieldEnd()
3431 rajveer 8784 
    if self.warehouse_id is not None:
999 varun.gupt 8785 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8786 
      oprot.writeI64(self.warehouse_id)
8787 
      oprot.writeFieldEnd()
8788 
    oprot.writeFieldStop()
8789 
    oprot.writeStructEnd()
8790 
 
3431 rajveer 8791 
  def validate(self):
8792 
    return
8793 
 
8794 
 
999 varun.gupt 8795 
  def __repr__(self):
8796 
    L = ['%s=%r' % (key, value)
8797 
      for key, value in self.__dict__.iteritems()]
8798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8799 
 
8800 
  def __eq__(self, other):
8801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8802 
 
8803 
  def __ne__(self, other):
8804 
    return not (self == other)
8805 
 
8806 
class getOrdersByBillingDate_result:
8807 
  """
8808 
  Attributes:
8809 
   - success
8810 
   - ex
8811 
  """
8812 
 
8813 
  thrift_spec = (
8814 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8816 
  )
8817 
 
8818 
  def __init__(self, success=None, ex=None,):
8819 
    self.success = success
8820 
    self.ex = ex
8821 
 
8822 
  def read(self, iprot):
8823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8825 
      return
8826 
    iprot.readStructBegin()
8827 
    while True:
8828 
      (fname, ftype, fid) = iprot.readFieldBegin()
8829 
      if ftype == TType.STOP:
8830 
        break
8831 
      if fid == 0:
8832 
        if ftype == TType.LIST:
8833 
          self.success = []
5031 varun.gupt 8834 
          (_etype115, _size112) = iprot.readListBegin()
8835 
          for _i116 in xrange(_size112):
8836 
            _elem117 = Order()
8837 
            _elem117.read(iprot)
8838 
            self.success.append(_elem117)
999 varun.gupt 8839 
          iprot.readListEnd()
8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      elif fid == 1:
8843 
        if ftype == TType.STRUCT:
8844 
          self.ex = TransactionServiceException()
8845 
          self.ex.read(iprot)
8846 
        else:
8847 
          iprot.skip(ftype)
8848 
      else:
8849 
        iprot.skip(ftype)
8850 
      iprot.readFieldEnd()
8851 
    iprot.readStructEnd()
8852 
 
8853 
  def write(self, oprot):
8854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8856 
      return
8857 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8858 
    if self.success is not None:
999 varun.gupt 8859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8861 
      for iter118 in self.success:
8862 
        iter118.write(oprot)
999 varun.gupt 8863 
      oprot.writeListEnd()
8864 
      oprot.writeFieldEnd()
3431 rajveer 8865 
    if self.ex is not None:
999 varun.gupt 8866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8867 
      self.ex.write(oprot)
8868 
      oprot.writeFieldEnd()
8869 
    oprot.writeFieldStop()
8870 
    oprot.writeStructEnd()
8871 
 
3431 rajveer 8872 
  def validate(self):
8873 
    return
8874 
 
8875 
 
999 varun.gupt 8876 
  def __repr__(self):
8877 
    L = ['%s=%r' % (key, value)
8878 
      for key, value in self.__dict__.iteritems()]
8879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8880 
 
8881 
  def __eq__(self, other):
8882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8883 
 
8884 
  def __ne__(self, other):
8885 
    return not (self == other)
8886 
 
3427 chandransh 8887 
class getOrdersByShippingDate_args:
8888 
  """
8889 
  Attributes:
8890 
   - fromShippingDate
8891 
   - toShippingDate
8892 
   - providerId
8893 
   - warehouseId
3451 chandransh 8894 
   - cod
3427 chandransh 8895 
  """
8896 
 
8897 
  thrift_spec = (
8898 
    None, # 0
8899 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8900 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8901 
    (3, TType.I64, 'providerId', None, None, ), # 3
8902 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8903 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8904 
  )
8905 
 
3451 chandransh 8906 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8907 
    self.fromShippingDate = fromShippingDate
8908 
    self.toShippingDate = toShippingDate
8909 
    self.providerId = providerId
8910 
    self.warehouseId = warehouseId
3451 chandransh 8911 
    self.cod = cod
3427 chandransh 8912 
 
8913 
  def read(self, iprot):
8914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8916 
      return
8917 
    iprot.readStructBegin()
8918 
    while True:
8919 
      (fname, ftype, fid) = iprot.readFieldBegin()
8920 
      if ftype == TType.STOP:
8921 
        break
8922 
      if fid == 1:
8923 
        if ftype == TType.I64:
8924 
          self.fromShippingDate = iprot.readI64();
8925 
        else:
8926 
          iprot.skip(ftype)
8927 
      elif fid == 2:
8928 
        if ftype == TType.I64:
8929 
          self.toShippingDate = iprot.readI64();
8930 
        else:
8931 
          iprot.skip(ftype)
8932 
      elif fid == 3:
8933 
        if ftype == TType.I64:
8934 
          self.providerId = iprot.readI64();
8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      elif fid == 4:
8938 
        if ftype == TType.I64:
8939 
          self.warehouseId = iprot.readI64();
8940 
        else:
8941 
          iprot.skip(ftype)
3451 chandransh 8942 
      elif fid == 5:
8943 
        if ftype == TType.BOOL:
8944 
          self.cod = iprot.readBool();
8945 
        else:
8946 
          iprot.skip(ftype)
3427 chandransh 8947 
      else:
8948 
        iprot.skip(ftype)
8949 
      iprot.readFieldEnd()
8950 
    iprot.readStructEnd()
8951 
 
8952 
  def write(self, oprot):
8953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8955 
      return
8956 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8957 
    if self.fromShippingDate is not None:
3427 chandransh 8958 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8959 
      oprot.writeI64(self.fromShippingDate)
8960 
      oprot.writeFieldEnd()
3431 rajveer 8961 
    if self.toShippingDate is not None:
3427 chandransh 8962 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8963 
      oprot.writeI64(self.toShippingDate)
8964 
      oprot.writeFieldEnd()
3431 rajveer 8965 
    if self.providerId is not None:
3427 chandransh 8966 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8967 
      oprot.writeI64(self.providerId)
8968 
      oprot.writeFieldEnd()
3431 rajveer 8969 
    if self.warehouseId is not None:
3427 chandransh 8970 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8971 
      oprot.writeI64(self.warehouseId)
8972 
      oprot.writeFieldEnd()
3451 chandransh 8973 
    if self.cod is not None:
8974 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8975 
      oprot.writeBool(self.cod)
8976 
      oprot.writeFieldEnd()
3427 chandransh 8977 
    oprot.writeFieldStop()
8978 
    oprot.writeStructEnd()
8979 
 
3431 rajveer 8980 
  def validate(self):
8981 
    return
8982 
 
8983 
 
3427 chandransh 8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getOrdersByShippingDate_result:
8996 
  """
8997 
  Attributes:
8998 
   - success
8999 
   - ex
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, success=None, ex=None,):
9008 
    self.success = success
9009 
    self.ex = ex
9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 0:
9021 
        if ftype == TType.LIST:
9022 
          self.success = []
5031 varun.gupt 9023 
          (_etype122, _size119) = iprot.readListBegin()
9024 
          for _i123 in xrange(_size119):
9025 
            _elem124 = Order()
9026 
            _elem124.read(iprot)
9027 
            self.success.append(_elem124)
3427 chandransh 9028 
          iprot.readListEnd()
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      elif fid == 1:
9032 
        if ftype == TType.STRUCT:
9033 
          self.ex = TransactionServiceException()
9034 
          self.ex.read(iprot)
9035 
        else:
9036 
          iprot.skip(ftype)
9037 
      else:
9038 
        iprot.skip(ftype)
9039 
      iprot.readFieldEnd()
9040 
    iprot.readStructEnd()
9041 
 
9042 
  def write(self, oprot):
9043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9045 
      return
9046 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9047 
    if self.success is not None:
3427 chandransh 9048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9050 
      for iter125 in self.success:
9051 
        iter125.write(oprot)
3427 chandransh 9052 
      oprot.writeListEnd()
9053 
      oprot.writeFieldEnd()
3431 rajveer 9054 
    if self.ex is not None:
3427 chandransh 9055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9056 
      self.ex.write(oprot)
9057 
      oprot.writeFieldEnd()
9058 
    oprot.writeFieldStop()
9059 
    oprot.writeStructEnd()
9060 
 
3431 rajveer 9061 
  def validate(self):
9062 
    return
9063 
 
9064 
 
3427 chandransh 9065 
  def __repr__(self):
9066 
    L = ['%s=%r' % (key, value)
9067 
      for key, value in self.__dict__.iteritems()]
9068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9069 
 
9070 
  def __eq__(self, other):
9071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9072 
 
9073 
  def __ne__(self, other):
9074 
    return not (self == other)
9075 
 
1382 varun.gupt 9076 
class getReturnableOrdersForCustomer_args:
9077 
  """
9078 
  Attributes:
9079 
   - customer_id
9080 
   - limit
9081 
  """
9082 
 
9083 
  thrift_spec = (
9084 
    None, # 0
9085 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9086 
    (2, TType.I64, 'limit', None, None, ), # 2
9087 
  )
9088 
 
9089 
  def __init__(self, customer_id=None, limit=None,):
9090 
    self.customer_id = customer_id
9091 
    self.limit = limit
9092 
 
9093 
  def read(self, iprot):
9094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9096 
      return
9097 
    iprot.readStructBegin()
9098 
    while True:
9099 
      (fname, ftype, fid) = iprot.readFieldBegin()
9100 
      if ftype == TType.STOP:
9101 
        break
9102 
      if fid == 1:
9103 
        if ftype == TType.I64:
9104 
          self.customer_id = iprot.readI64();
9105 
        else:
9106 
          iprot.skip(ftype)
9107 
      elif fid == 2:
9108 
        if ftype == TType.I64:
9109 
          self.limit = iprot.readI64();
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      else:
9113 
        iprot.skip(ftype)
9114 
      iprot.readFieldEnd()
9115 
    iprot.readStructEnd()
9116 
 
9117 
  def write(self, oprot):
9118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9120 
      return
9121 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9122 
    if self.customer_id is not None:
1382 varun.gupt 9123 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9124 
      oprot.writeI64(self.customer_id)
9125 
      oprot.writeFieldEnd()
3431 rajveer 9126 
    if self.limit is not None:
1382 varun.gupt 9127 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9128 
      oprot.writeI64(self.limit)
9129 
      oprot.writeFieldEnd()
9130 
    oprot.writeFieldStop()
9131 
    oprot.writeStructEnd()
9132 
 
3431 rajveer 9133 
  def validate(self):
9134 
    return
9135 
 
9136 
 
1382 varun.gupt 9137 
  def __repr__(self):
9138 
    L = ['%s=%r' % (key, value)
9139 
      for key, value in self.__dict__.iteritems()]
9140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9141 
 
9142 
  def __eq__(self, other):
9143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9144 
 
9145 
  def __ne__(self, other):
9146 
    return not (self == other)
9147 
 
9148 
class getReturnableOrdersForCustomer_result:
9149 
  """
9150 
  Attributes:
9151 
   - success
9152 
   - ex
9153 
  """
9154 
 
9155 
  thrift_spec = (
9156 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9158 
  )
9159 
 
9160 
  def __init__(self, success=None, ex=None,):
9161 
    self.success = success
9162 
    self.ex = ex
9163 
 
9164 
  def read(self, iprot):
9165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9167 
      return
9168 
    iprot.readStructBegin()
9169 
    while True:
9170 
      (fname, ftype, fid) = iprot.readFieldBegin()
9171 
      if ftype == TType.STOP:
9172 
        break
9173 
      if fid == 0:
9174 
        if ftype == TType.LIST:
9175 
          self.success = []
5031 varun.gupt 9176 
          (_etype129, _size126) = iprot.readListBegin()
9177 
          for _i130 in xrange(_size126):
9178 
            _elem131 = iprot.readI64();
9179 
            self.success.append(_elem131)
1382 varun.gupt 9180 
          iprot.readListEnd()
9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      elif fid == 1:
9184 
        if ftype == TType.STRUCT:
9185 
          self.ex = TransactionServiceException()
9186 
          self.ex.read(iprot)
9187 
        else:
9188 
          iprot.skip(ftype)
9189 
      else:
9190 
        iprot.skip(ftype)
9191 
      iprot.readFieldEnd()
9192 
    iprot.readStructEnd()
9193 
 
9194 
  def write(self, oprot):
9195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9197 
      return
9198 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9199 
    if self.success is not None:
1382 varun.gupt 9200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9201 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9202 
      for iter132 in self.success:
9203 
        oprot.writeI64(iter132)
1382 varun.gupt 9204 
      oprot.writeListEnd()
9205 
      oprot.writeFieldEnd()
3431 rajveer 9206 
    if self.ex is not None:
1382 varun.gupt 9207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9208 
      self.ex.write(oprot)
9209 
      oprot.writeFieldEnd()
9210 
    oprot.writeFieldStop()
9211 
    oprot.writeStructEnd()
9212 
 
3431 rajveer 9213 
  def validate(self):
9214 
    return
9215 
 
9216 
 
1382 varun.gupt 9217 
  def __repr__(self):
9218 
    L = ['%s=%r' % (key, value)
9219 
      for key, value in self.__dict__.iteritems()]
9220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9221 
 
9222 
  def __eq__(self, other):
9223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9224 
 
9225 
  def __ne__(self, other):
9226 
    return not (self == other)
9227 
 
9228 
class getCancellableOrdersForCustomer_args:
9229 
  """
9230 
  Attributes:
9231 
   - customer_id
9232 
   - limit
9233 
  """
9234 
 
9235 
  thrift_spec = (
9236 
    None, # 0
9237 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9238 
    (2, TType.I64, 'limit', None, None, ), # 2
9239 
  )
9240 
 
9241 
  def __init__(self, customer_id=None, limit=None,):
9242 
    self.customer_id = customer_id
9243 
    self.limit = limit
9244 
 
9245 
  def read(self, iprot):
9246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9248 
      return
9249 
    iprot.readStructBegin()
9250 
    while True:
9251 
      (fname, ftype, fid) = iprot.readFieldBegin()
9252 
      if ftype == TType.STOP:
9253 
        break
9254 
      if fid == 1:
9255 
        if ftype == TType.I64:
9256 
          self.customer_id = iprot.readI64();
9257 
        else:
9258 
          iprot.skip(ftype)
9259 
      elif fid == 2:
9260 
        if ftype == TType.I64:
9261 
          self.limit = iprot.readI64();
9262 
        else:
9263 
          iprot.skip(ftype)
9264 
      else:
9265 
        iprot.skip(ftype)
9266 
      iprot.readFieldEnd()
9267 
    iprot.readStructEnd()
9268 
 
9269 
  def write(self, oprot):
9270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9272 
      return
9273 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9274 
    if self.customer_id is not None:
1382 varun.gupt 9275 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9276 
      oprot.writeI64(self.customer_id)
9277 
      oprot.writeFieldEnd()
3431 rajveer 9278 
    if self.limit is not None:
1382 varun.gupt 9279 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9280 
      oprot.writeI64(self.limit)
9281 
      oprot.writeFieldEnd()
9282 
    oprot.writeFieldStop()
9283 
    oprot.writeStructEnd()
9284 
 
3431 rajveer 9285 
  def validate(self):
9286 
    return
9287 
 
9288 
 
1382 varun.gupt 9289 
  def __repr__(self):
9290 
    L = ['%s=%r' % (key, value)
9291 
      for key, value in self.__dict__.iteritems()]
9292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9293 
 
9294 
  def __eq__(self, other):
9295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9296 
 
9297 
  def __ne__(self, other):
9298 
    return not (self == other)
9299 
 
9300 
class getCancellableOrdersForCustomer_result:
9301 
  """
9302 
  Attributes:
9303 
   - success
9304 
   - ex
9305 
  """
9306 
 
9307 
  thrift_spec = (
9308 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9310 
  )
9311 
 
9312 
  def __init__(self, success=None, ex=None,):
9313 
    self.success = success
9314 
    self.ex = ex
9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 0:
9326 
        if ftype == TType.LIST:
9327 
          self.success = []
5031 varun.gupt 9328 
          (_etype136, _size133) = iprot.readListBegin()
9329 
          for _i137 in xrange(_size133):
9330 
            _elem138 = iprot.readI64();
9331 
            self.success.append(_elem138)
1382 varun.gupt 9332 
          iprot.readListEnd()
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      elif fid == 1:
9336 
        if ftype == TType.STRUCT:
9337 
          self.ex = TransactionServiceException()
9338 
          self.ex.read(iprot)
9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      else:
9342 
        iprot.skip(ftype)
9343 
      iprot.readFieldEnd()
9344 
    iprot.readStructEnd()
9345 
 
9346 
  def write(self, oprot):
9347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9349 
      return
9350 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9351 
    if self.success is not None:
1382 varun.gupt 9352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9353 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9354 
      for iter139 in self.success:
9355 
        oprot.writeI64(iter139)
1382 varun.gupt 9356 
      oprot.writeListEnd()
9357 
      oprot.writeFieldEnd()
3431 rajveer 9358 
    if self.ex is not None:
1382 varun.gupt 9359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9360 
      self.ex.write(oprot)
9361 
      oprot.writeFieldEnd()
9362 
    oprot.writeFieldStop()
9363 
    oprot.writeStructEnd()
9364 
 
3431 rajveer 9365 
  def validate(self):
9366 
    return
9367 
 
9368 
 
1382 varun.gupt 9369 
  def __repr__(self):
9370 
    L = ['%s=%r' % (key, value)
9371 
      for key, value in self.__dict__.iteritems()]
9372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9373 
 
9374 
  def __eq__(self, other):
9375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9376 
 
9377 
  def __ne__(self, other):
9378 
    return not (self == other)
9379 
 
483 rajveer 9380 
class changeOrderStatus_args:
94 ashish 9381 
  """
9382 
  Attributes:
483 rajveer 9383 
   - orderId
9384 
   - status
9385 
   - description
94 ashish 9386 
  """
9387 
 
9388 
  thrift_spec = (
9389 
    None, # 0
483 rajveer 9390 
    (1, TType.I64, 'orderId', None, None, ), # 1
9391 
    (2, TType.I32, 'status', None, None, ), # 2
9392 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9393 
  )
9394 
 
483 rajveer 9395 
  def __init__(self, orderId=None, status=None, description=None,):
9396 
    self.orderId = orderId
9397 
    self.status = status
9398 
    self.description = description
94 ashish 9399 
 
9400 
  def read(self, iprot):
9401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9403 
      return
9404 
    iprot.readStructBegin()
9405 
    while True:
9406 
      (fname, ftype, fid) = iprot.readFieldBegin()
9407 
      if ftype == TType.STOP:
9408 
        break
9409 
      if fid == 1:
9410 
        if ftype == TType.I64:
483 rajveer 9411 
          self.orderId = iprot.readI64();
94 ashish 9412 
        else:
9413 
          iprot.skip(ftype)
9414 
      elif fid == 2:
483 rajveer 9415 
        if ftype == TType.I32:
9416 
          self.status = iprot.readI32();
94 ashish 9417 
        else:
9418 
          iprot.skip(ftype)
483 rajveer 9419 
      elif fid == 3:
9420 
        if ftype == TType.STRING:
9421 
          self.description = iprot.readString();
9422 
        else:
9423 
          iprot.skip(ftype)
94 ashish 9424 
      else:
9425 
        iprot.skip(ftype)
9426 
      iprot.readFieldEnd()
9427 
    iprot.readStructEnd()
9428 
 
9429 
  def write(self, oprot):
9430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9432 
      return
483 rajveer 9433 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9434 
    if self.orderId is not None:
483 rajveer 9435 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9436 
      oprot.writeI64(self.orderId)
94 ashish 9437 
      oprot.writeFieldEnd()
3431 rajveer 9438 
    if self.status is not None:
483 rajveer 9439 
      oprot.writeFieldBegin('status', TType.I32, 2)
9440 
      oprot.writeI32(self.status)
94 ashish 9441 
      oprot.writeFieldEnd()
3431 rajveer 9442 
    if self.description is not None:
483 rajveer 9443 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9444 
      oprot.writeString(self.description)
9445 
      oprot.writeFieldEnd()
94 ashish 9446 
    oprot.writeFieldStop()
9447 
    oprot.writeStructEnd()
9448 
 
3431 rajveer 9449 
  def validate(self):
9450 
    return
9451 
 
9452 
 
94 ashish 9453 
  def __repr__(self):
9454 
    L = ['%s=%r' % (key, value)
9455 
      for key, value in self.__dict__.iteritems()]
9456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9457 
 
9458 
  def __eq__(self, other):
9459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9460 
 
9461 
  def __ne__(self, other):
9462 
    return not (self == other)
9463 
 
483 rajveer 9464 
class changeOrderStatus_result:
94 ashish 9465 
  """
9466 
  Attributes:
9467 
   - success
9468 
   - ex
9469 
  """
9470 
 
9471 
  thrift_spec = (
9472 
    (0, TType.BOOL, 'success', None, None, ), # 0
9473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9474 
  )
9475 
 
9476 
  def __init__(self, success=None, ex=None,):
9477 
    self.success = success
9478 
    self.ex = ex
9479 
 
9480 
  def read(self, iprot):
9481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9483 
      return
9484 
    iprot.readStructBegin()
9485 
    while True:
9486 
      (fname, ftype, fid) = iprot.readFieldBegin()
9487 
      if ftype == TType.STOP:
9488 
        break
9489 
      if fid == 0:
9490 
        if ftype == TType.BOOL:
9491 
          self.success = iprot.readBool();
9492 
        else:
9493 
          iprot.skip(ftype)
9494 
      elif fid == 1:
9495 
        if ftype == TType.STRUCT:
9496 
          self.ex = TransactionServiceException()
9497 
          self.ex.read(iprot)
9498 
        else:
9499 
          iprot.skip(ftype)
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
483 rajveer 9509 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9510 
    if self.success is not None:
94 ashish 9511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9512 
      oprot.writeBool(self.success)
9513 
      oprot.writeFieldEnd()
3431 rajveer 9514 
    if self.ex is not None:
94 ashish 9515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9516 
      self.ex.write(oprot)
9517 
      oprot.writeFieldEnd()
9518 
    oprot.writeFieldStop()
9519 
    oprot.writeStructEnd()
9520 
 
3431 rajveer 9521 
  def validate(self):
9522 
    return
9523 
 
9524 
 
94 ashish 9525 
  def __repr__(self):
9526 
    L = ['%s=%r' % (key, value)
9527 
      for key, value in self.__dict__.iteritems()]
9528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9529 
 
9530 
  def __eq__(self, other):
9531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9532 
 
9533 
  def __ne__(self, other):
9534 
    return not (self == other)
9535 
 
3064 chandransh 9536 
class getOrdersForTransaction_args:
494 rajveer 9537 
  """
9538 
  Attributes:
3064 chandransh 9539 
   - transactionId
9540 
   - customerId
494 rajveer 9541 
  """
9542 
 
9543 
  thrift_spec = (
9544 
    None, # 0
3064 chandransh 9545 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9546 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9547 
  )
9548 
 
3064 chandransh 9549 
  def __init__(self, transactionId=None, customerId=None,):
9550 
    self.transactionId = transactionId
9551 
    self.customerId = customerId
494 rajveer 9552 
 
9553 
  def read(self, iprot):
9554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9556 
      return
9557 
    iprot.readStructBegin()
9558 
    while True:
9559 
      (fname, ftype, fid) = iprot.readFieldBegin()
9560 
      if ftype == TType.STOP:
9561 
        break
9562 
      if fid == 1:
9563 
        if ftype == TType.I64:
3064 chandransh 9564 
          self.transactionId = iprot.readI64();
494 rajveer 9565 
        else:
9566 
          iprot.skip(ftype)
9567 
      elif fid == 2:
3064 chandransh 9568 
        if ftype == TType.I64:
9569 
          self.customerId = iprot.readI64();
494 rajveer 9570 
        else:
9571 
          iprot.skip(ftype)
9572 
      else:
9573 
        iprot.skip(ftype)
9574 
      iprot.readFieldEnd()
9575 
    iprot.readStructEnd()
9576 
 
9577 
  def write(self, oprot):
9578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9580 
      return
3064 chandransh 9581 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9582 
    if self.transactionId is not None:
3064 chandransh 9583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9584 
      oprot.writeI64(self.transactionId)
494 rajveer 9585 
      oprot.writeFieldEnd()
3431 rajveer 9586 
    if self.customerId is not None:
3064 chandransh 9587 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9588 
      oprot.writeI64(self.customerId)
494 rajveer 9589 
      oprot.writeFieldEnd()
9590 
    oprot.writeFieldStop()
9591 
    oprot.writeStructEnd()
9592 
 
3431 rajveer 9593 
  def validate(self):
9594 
    return
9595 
 
9596 
 
494 rajveer 9597 
  def __repr__(self):
9598 
    L = ['%s=%r' % (key, value)
9599 
      for key, value in self.__dict__.iteritems()]
9600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9601 
 
9602 
  def __eq__(self, other):
9603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9604 
 
9605 
  def __ne__(self, other):
9606 
    return not (self == other)
9607 
 
3064 chandransh 9608 
class getOrdersForTransaction_result:
494 rajveer 9609 
  """
9610 
  Attributes:
9611 
   - success
9612 
   - ex
9613 
  """
9614 
 
9615 
  thrift_spec = (
3064 chandransh 9616 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9618 
  )
9619 
 
9620 
  def __init__(self, success=None, ex=None,):
9621 
    self.success = success
9622 
    self.ex = ex
9623 
 
9624 
  def read(self, iprot):
9625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9627 
      return
9628 
    iprot.readStructBegin()
9629 
    while True:
9630 
      (fname, ftype, fid) = iprot.readFieldBegin()
9631 
      if ftype == TType.STOP:
9632 
        break
9633 
      if fid == 0:
3064 chandransh 9634 
        if ftype == TType.LIST:
9635 
          self.success = []
5031 varun.gupt 9636 
          (_etype143, _size140) = iprot.readListBegin()
9637 
          for _i144 in xrange(_size140):
9638 
            _elem145 = Order()
9639 
            _elem145.read(iprot)
9640 
            self.success.append(_elem145)
3064 chandransh 9641 
          iprot.readListEnd()
494 rajveer 9642 
        else:
9643 
          iprot.skip(ftype)
9644 
      elif fid == 1:
9645 
        if ftype == TType.STRUCT:
9646 
          self.ex = TransactionServiceException()
9647 
          self.ex.read(iprot)
9648 
        else:
9649 
          iprot.skip(ftype)
9650 
      else:
9651 
        iprot.skip(ftype)
9652 
      iprot.readFieldEnd()
9653 
    iprot.readStructEnd()
9654 
 
9655 
  def write(self, oprot):
9656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9658 
      return
3064 chandransh 9659 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9660 
    if self.success is not None:
3064 chandransh 9661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9663 
      for iter146 in self.success:
9664 
        iter146.write(oprot)
3064 chandransh 9665 
      oprot.writeListEnd()
494 rajveer 9666 
      oprot.writeFieldEnd()
3431 rajveer 9667 
    if self.ex is not None:
494 rajveer 9668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9669 
      self.ex.write(oprot)
9670 
      oprot.writeFieldEnd()
9671 
    oprot.writeFieldStop()
9672 
    oprot.writeStructEnd()
9673 
 
3431 rajveer 9674 
  def validate(self):
9675 
    return
9676 
 
9677 
 
494 rajveer 9678 
  def __repr__(self):
9679 
    L = ['%s=%r' % (key, value)
9680 
      for key, value in self.__dict__.iteritems()]
9681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9682 
 
9683 
  def __eq__(self, other):
9684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9685 
 
9686 
  def __ne__(self, other):
9687 
    return not (self == other)
9688 
 
3064 chandransh 9689 
class getOrdersForCustomer_args:
1149 chandransh 9690 
  """
9691 
  Attributes:
3064 chandransh 9692 
   - customerId
9693 
   - from_date
9694 
   - to_date
9695 
   - statuses
1149 chandransh 9696 
  """
9697 
 
9698 
  thrift_spec = (
9699 
    None, # 0
3064 chandransh 9700 
    (1, TType.I64, 'customerId', None, None, ), # 1
9701 
    (2, TType.I64, 'from_date', None, None, ), # 2
9702 
    (3, TType.I64, 'to_date', None, None, ), # 3
9703 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9704 
  )
9705 
 
3064 chandransh 9706 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9707 
    self.customerId = customerId
9708 
    self.from_date = from_date
9709 
    self.to_date = to_date
9710 
    self.statuses = statuses
1149 chandransh 9711 
 
9712 
  def read(self, iprot):
9713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9715 
      return
9716 
    iprot.readStructBegin()
9717 
    while True:
9718 
      (fname, ftype, fid) = iprot.readFieldBegin()
9719 
      if ftype == TType.STOP:
9720 
        break
9721 
      if fid == 1:
9722 
        if ftype == TType.I64:
3064 chandransh 9723 
          self.customerId = iprot.readI64();
1149 chandransh 9724 
        else:
9725 
          iprot.skip(ftype)
9726 
      elif fid == 2:
9727 
        if ftype == TType.I64:
3064 chandransh 9728 
          self.from_date = iprot.readI64();
1149 chandransh 9729 
        else:
9730 
          iprot.skip(ftype)
2783 chandransh 9731 
      elif fid == 3:
9732 
        if ftype == TType.I64:
3064 chandransh 9733 
          self.to_date = iprot.readI64();
2783 chandransh 9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      elif fid == 4:
3064 chandransh 9737 
        if ftype == TType.LIST:
9738 
          self.statuses = []
5031 varun.gupt 9739 
          (_etype150, _size147) = iprot.readListBegin()
9740 
          for _i151 in xrange(_size147):
9741 
            _elem152 = iprot.readI32();
9742 
            self.statuses.append(_elem152)
3064 chandransh 9743 
          iprot.readListEnd()
2783 chandransh 9744 
        else:
9745 
          iprot.skip(ftype)
1149 chandransh 9746 
      else:
9747 
        iprot.skip(ftype)
9748 
      iprot.readFieldEnd()
9749 
    iprot.readStructEnd()
9750 
 
9751 
  def write(self, oprot):
9752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9754 
      return
3064 chandransh 9755 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9756 
    if self.customerId is not None:
3064 chandransh 9757 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9758 
      oprot.writeI64(self.customerId)
1149 chandransh 9759 
      oprot.writeFieldEnd()
3431 rajveer 9760 
    if self.from_date is not None:
3064 chandransh 9761 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9762 
      oprot.writeI64(self.from_date)
1149 chandransh 9763 
      oprot.writeFieldEnd()
3431 rajveer 9764 
    if self.to_date is not None:
3064 chandransh 9765 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9766 
      oprot.writeI64(self.to_date)
2783 chandransh 9767 
      oprot.writeFieldEnd()
3431 rajveer 9768 
    if self.statuses is not None:
3064 chandransh 9769 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9770 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9771 
      for iter153 in self.statuses:
9772 
        oprot.writeI32(iter153)
3064 chandransh 9773 
      oprot.writeListEnd()
2783 chandransh 9774 
      oprot.writeFieldEnd()
1149 chandransh 9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
3431 rajveer 9778 
  def validate(self):
9779 
    return
9780 
 
9781 
 
1149 chandransh 9782 
  def __repr__(self):
9783 
    L = ['%s=%r' % (key, value)
9784 
      for key, value in self.__dict__.iteritems()]
9785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9786 
 
9787 
  def __eq__(self, other):
9788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9789 
 
9790 
  def __ne__(self, other):
9791 
    return not (self == other)
9792 
 
3064 chandransh 9793 
class getOrdersForCustomer_result:
1149 chandransh 9794 
  """
9795 
  Attributes:
9796 
   - success
9797 
   - ex
9798 
  """
9799 
 
9800 
  thrift_spec = (
3064 chandransh 9801 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9803 
  )
9804 
 
9805 
  def __init__(self, success=None, ex=None,):
9806 
    self.success = success
9807 
    self.ex = ex
9808 
 
9809 
  def read(self, iprot):
9810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9812 
      return
9813 
    iprot.readStructBegin()
9814 
    while True:
9815 
      (fname, ftype, fid) = iprot.readFieldBegin()
9816 
      if ftype == TType.STOP:
9817 
        break
9818 
      if fid == 0:
3064 chandransh 9819 
        if ftype == TType.LIST:
9820 
          self.success = []
5031 varun.gupt 9821 
          (_etype157, _size154) = iprot.readListBegin()
9822 
          for _i158 in xrange(_size154):
9823 
            _elem159 = Order()
9824 
            _elem159.read(iprot)
9825 
            self.success.append(_elem159)
3064 chandransh 9826 
          iprot.readListEnd()
1149 chandransh 9827 
        else:
9828 
          iprot.skip(ftype)
9829 
      elif fid == 1:
9830 
        if ftype == TType.STRUCT:
9831 
          self.ex = TransactionServiceException()
9832 
          self.ex.read(iprot)
9833 
        else:
9834 
          iprot.skip(ftype)
9835 
      else:
9836 
        iprot.skip(ftype)
9837 
      iprot.readFieldEnd()
9838 
    iprot.readStructEnd()
9839 
 
9840 
  def write(self, oprot):
9841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9843 
      return
3064 chandransh 9844 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9845 
    if self.success is not None:
3064 chandransh 9846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9848 
      for iter160 in self.success:
9849 
        iter160.write(oprot)
3064 chandransh 9850 
      oprot.writeListEnd()
1149 chandransh 9851 
      oprot.writeFieldEnd()
3431 rajveer 9852 
    if self.ex is not None:
1149 chandransh 9853 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9854 
      self.ex.write(oprot)
9855 
      oprot.writeFieldEnd()
9856 
    oprot.writeFieldStop()
9857 
    oprot.writeStructEnd()
9858 
 
3431 rajveer 9859 
  def validate(self):
9860 
    return
9861 
 
9862 
 
1149 chandransh 9863 
  def __repr__(self):
9864 
    L = ['%s=%r' % (key, value)
9865 
      for key, value in self.__dict__.iteritems()]
9866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9867 
 
9868 
  def __eq__(self, other):
9869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9870 
 
9871 
  def __ne__(self, other):
9872 
    return not (self == other)
9873 
 
3064 chandransh 9874 
class createOrder_args:
921 rajveer 9875 
  """
9876 
  Attributes:
3064 chandransh 9877 
   - order
921 rajveer 9878 
  """
9879 
 
9880 
  thrift_spec = (
9881 
    None, # 0
3064 chandransh 9882 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9883 
  )
9884 
 
3064 chandransh 9885 
  def __init__(self, order=None,):
9886 
    self.order = order
921 rajveer 9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 1:
3064 chandransh 9898 
        if ftype == TType.STRUCT:
9899 
          self.order = Order()
9900 
          self.order.read(iprot)
921 rajveer 9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
3064 chandransh 9912 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9913 
    if self.order is not None:
3064 chandransh 9914 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9915 
      self.order.write(oprot)
921 rajveer 9916 
      oprot.writeFieldEnd()
9917 
    oprot.writeFieldStop()
9918 
    oprot.writeStructEnd()
9919 
 
3431 rajveer 9920 
  def validate(self):
9921 
    return
9922 
 
9923 
 
921 rajveer 9924 
  def __repr__(self):
9925 
    L = ['%s=%r' % (key, value)
9926 
      for key, value in self.__dict__.iteritems()]
9927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9928 
 
9929 
  def __eq__(self, other):
9930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9931 
 
9932 
  def __ne__(self, other):
9933 
    return not (self == other)
9934 
 
3064 chandransh 9935 
class createOrder_result:
921 rajveer 9936 
  """
9937 
  Attributes:
9938 
   - success
9939 
   - ex
9940 
  """
9941 
 
9942 
  thrift_spec = (
3064 chandransh 9943 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9945 
  )
9946 
 
9947 
  def __init__(self, success=None, ex=None,):
9948 
    self.success = success
9949 
    self.ex = ex
9950 
 
9951 
  def read(self, iprot):
9952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9954 
      return
9955 
    iprot.readStructBegin()
9956 
    while True:
9957 
      (fname, ftype, fid) = iprot.readFieldBegin()
9958 
      if ftype == TType.STOP:
9959 
        break
9960 
      if fid == 0:
3064 chandransh 9961 
        if ftype == TType.I64:
9962 
          self.success = iprot.readI64();
921 rajveer 9963 
        else:
9964 
          iprot.skip(ftype)
9965 
      elif fid == 1:
9966 
        if ftype == TType.STRUCT:
9967 
          self.ex = TransactionServiceException()
9968 
          self.ex.read(iprot)
9969 
        else:
9970 
          iprot.skip(ftype)
9971 
      else:
9972 
        iprot.skip(ftype)
9973 
      iprot.readFieldEnd()
9974 
    iprot.readStructEnd()
9975 
 
9976 
  def write(self, oprot):
9977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9979 
      return
3064 chandransh 9980 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9981 
    if self.success is not None:
3064 chandransh 9982 
      oprot.writeFieldBegin('success', TType.I64, 0)
9983 
      oprot.writeI64(self.success)
921 rajveer 9984 
      oprot.writeFieldEnd()
3431 rajveer 9985 
    if self.ex is not None:
921 rajveer 9986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9987 
      self.ex.write(oprot)
9988 
      oprot.writeFieldEnd()
9989 
    oprot.writeFieldStop()
9990 
    oprot.writeStructEnd()
9991 
 
3431 rajveer 9992 
  def validate(self):
9993 
    return
9994 
 
9995 
 
921 rajveer 9996 
  def __repr__(self):
9997 
    L = ['%s=%r' % (key, value)
9998 
      for key, value in self.__dict__.iteritems()]
9999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10000 
 
10001 
  def __eq__(self, other):
10002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10003 
 
10004 
  def __ne__(self, other):
10005 
    return not (self == other)
10006 
 
3064 chandransh 10007 
class getOrder_args:
921 rajveer 10008 
  """
10009 
  Attributes:
3064 chandransh 10010 
   - id
921 rajveer 10011 
  """
10012 
 
10013 
  thrift_spec = (
10014 
    None, # 0
3064 chandransh 10015 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10016 
  )
10017 
 
3064 chandransh 10018 
  def __init__(self, id=None,):
10019 
    self.id = id
921 rajveer 10020 
 
10021 
  def read(self, iprot):
10022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10024 
      return
10025 
    iprot.readStructBegin()
10026 
    while True:
10027 
      (fname, ftype, fid) = iprot.readFieldBegin()
10028 
      if ftype == TType.STOP:
10029 
        break
10030 
      if fid == 1:
10031 
        if ftype == TType.I64:
3064 chandransh 10032 
          self.id = iprot.readI64();
921 rajveer 10033 
        else:
10034 
          iprot.skip(ftype)
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
3064 chandransh 10044 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10045 
    if self.id is not None:
3064 chandransh 10046 
      oprot.writeFieldBegin('id', TType.I64, 1)
10047 
      oprot.writeI64(self.id)
921 rajveer 10048 
      oprot.writeFieldEnd()
10049 
    oprot.writeFieldStop()
10050 
    oprot.writeStructEnd()
10051 
 
3431 rajveer 10052 
  def validate(self):
10053 
    return
10054 
 
10055 
 
921 rajveer 10056 
  def __repr__(self):
10057 
    L = ['%s=%r' % (key, value)
10058 
      for key, value in self.__dict__.iteritems()]
10059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10060 
 
10061 
  def __eq__(self, other):
10062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10063 
 
10064 
  def __ne__(self, other):
10065 
    return not (self == other)
10066 
 
3064 chandransh 10067 
class getOrder_result:
921 rajveer 10068 
  """
10069 
  Attributes:
10070 
   - success
10071 
   - ex
10072 
  """
10073 
 
10074 
  thrift_spec = (
3064 chandransh 10075 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10077 
  )
10078 
 
10079 
  def __init__(self, success=None, ex=None,):
10080 
    self.success = success
10081 
    self.ex = ex
10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 0:
3064 chandransh 10093 
        if ftype == TType.STRUCT:
10094 
          self.success = Order()
10095 
          self.success.read(iprot)
921 rajveer 10096 
        else:
10097 
          iprot.skip(ftype)
10098 
      elif fid == 1:
10099 
        if ftype == TType.STRUCT:
10100 
          self.ex = TransactionServiceException()
10101 
          self.ex.read(iprot)
10102 
        else:
10103 
          iprot.skip(ftype)
10104 
      else:
10105 
        iprot.skip(ftype)
10106 
      iprot.readFieldEnd()
10107 
    iprot.readStructEnd()
10108 
 
10109 
  def write(self, oprot):
10110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10112 
      return
3064 chandransh 10113 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10114 
    if self.success is not None:
3064 chandransh 10115 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10116 
      self.success.write(oprot)
921 rajveer 10117 
      oprot.writeFieldEnd()
3431 rajveer 10118 
    if self.ex is not None:
921 rajveer 10119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10120 
      self.ex.write(oprot)
10121 
      oprot.writeFieldEnd()
10122 
    oprot.writeFieldStop()
10123 
    oprot.writeStructEnd()
10124 
 
3431 rajveer 10125 
  def validate(self):
10126 
    return
10127 
 
10128 
 
921 rajveer 10129 
  def __repr__(self):
10130 
    L = ['%s=%r' % (key, value)
10131 
      for key, value in self.__dict__.iteritems()]
10132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10133 
 
10134 
  def __eq__(self, other):
10135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10136 
 
10137 
  def __ne__(self, other):
10138 
    return not (self == other)
10139 
 
3064 chandransh 10140 
class getLineItemsForOrder_args:
94 ashish 10141 
  """
10142 
  Attributes:
3064 chandransh 10143 
   - orderId
94 ashish 10144 
  """
10145 
 
10146 
  thrift_spec = (
10147 
    None, # 0
3064 chandransh 10148 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10149 
  )
10150 
 
3064 chandransh 10151 
  def __init__(self, orderId=None,):
10152 
    self.orderId = orderId
94 ashish 10153 
 
10154 
  def read(self, iprot):
10155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10157 
      return
10158 
    iprot.readStructBegin()
10159 
    while True:
10160 
      (fname, ftype, fid) = iprot.readFieldBegin()
10161 
      if ftype == TType.STOP:
10162 
        break
10163 
      if fid == 1:
10164 
        if ftype == TType.I64:
3064 chandransh 10165 
          self.orderId = iprot.readI64();
94 ashish 10166 
        else:
10167 
          iprot.skip(ftype)
10168 
      else:
10169 
        iprot.skip(ftype)
10170 
      iprot.readFieldEnd()
10171 
    iprot.readStructEnd()
10172 
 
10173 
  def write(self, oprot):
10174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10176 
      return
3064 chandransh 10177 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10178 
    if self.orderId is not None:
3064 chandransh 10179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10180 
      oprot.writeI64(self.orderId)
94 ashish 10181 
      oprot.writeFieldEnd()
10182 
    oprot.writeFieldStop()
10183 
    oprot.writeStructEnd()
10184 
 
3431 rajveer 10185 
  def validate(self):
10186 
    return
10187 
 
10188 
 
94 ashish 10189 
  def __repr__(self):
10190 
    L = ['%s=%r' % (key, value)
10191 
      for key, value in self.__dict__.iteritems()]
10192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10193 
 
10194 
  def __eq__(self, other):
10195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10196 
 
10197 
  def __ne__(self, other):
10198 
    return not (self == other)
10199 
 
3064 chandransh 10200 
class getLineItemsForOrder_result:
94 ashish 10201 
  """
10202 
  Attributes:
10203 
   - success
10204 
   - ex
10205 
  """
10206 
 
10207 
  thrift_spec = (
3064 chandransh 10208 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10210 
  )
10211 
 
10212 
  def __init__(self, success=None, ex=None,):
10213 
    self.success = success
10214 
    self.ex = ex
10215 
 
10216 
  def read(self, iprot):
10217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10219 
      return
10220 
    iprot.readStructBegin()
10221 
    while True:
10222 
      (fname, ftype, fid) = iprot.readFieldBegin()
10223 
      if ftype == TType.STOP:
10224 
        break
10225 
      if fid == 0:
483 rajveer 10226 
        if ftype == TType.LIST:
10227 
          self.success = []
5031 varun.gupt 10228 
          (_etype164, _size161) = iprot.readListBegin()
10229 
          for _i165 in xrange(_size161):
10230 
            _elem166 = LineItem()
10231 
            _elem166.read(iprot)
10232 
            self.success.append(_elem166)
483 rajveer 10233 
          iprot.readListEnd()
94 ashish 10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      elif fid == 1:
10237 
        if ftype == TType.STRUCT:
10238 
          self.ex = TransactionServiceException()
10239 
          self.ex.read(iprot)
10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
3064 chandransh 10251 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10252 
    if self.success is not None:
483 rajveer 10253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10254 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10255 
      for iter167 in self.success:
10256 
        iter167.write(oprot)
483 rajveer 10257 
      oprot.writeListEnd()
94 ashish 10258 
      oprot.writeFieldEnd()
3431 rajveer 10259 
    if self.ex is not None:
94 ashish 10260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10261 
      self.ex.write(oprot)
10262 
      oprot.writeFieldEnd()
10263 
    oprot.writeFieldStop()
10264 
    oprot.writeStructEnd()
10265 
 
3431 rajveer 10266 
  def validate(self):
10267 
    return
10268 
 
10269 
 
94 ashish 10270 
  def __repr__(self):
10271 
    L = ['%s=%r' % (key, value)
10272 
      for key, value in self.__dict__.iteritems()]
10273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10274 
 
10275 
  def __eq__(self, other):
10276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10277 
 
10278 
  def __ne__(self, other):
10279 
    return not (self == other)
10280 
 
4999 phani.kuma 10281 
class getOrderList_args:
10282 
  """
10283 
  Attributes:
10284 
   - order_ids
10285 
  """
10286 
 
10287 
  thrift_spec = (
10288 
    None, # 0
10289 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10290 
  )
10291 
 
10292 
  def __init__(self, order_ids=None,):
10293 
    self.order_ids = order_ids
10294 
 
10295 
  def read(self, iprot):
10296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10298 
      return
10299 
    iprot.readStructBegin()
10300 
    while True:
10301 
      (fname, ftype, fid) = iprot.readFieldBegin()
10302 
      if ftype == TType.STOP:
10303 
        break
10304 
      if fid == 1:
10305 
        if ftype == TType.LIST:
10306 
          self.order_ids = []
5031 varun.gupt 10307 
          (_etype171, _size168) = iprot.readListBegin()
10308 
          for _i172 in xrange(_size168):
10309 
            _elem173 = iprot.readI64();
10310 
            self.order_ids.append(_elem173)
4999 phani.kuma 10311 
          iprot.readListEnd()
10312 
        else:
10313 
          iprot.skip(ftype)
10314 
      else:
10315 
        iprot.skip(ftype)
10316 
      iprot.readFieldEnd()
10317 
    iprot.readStructEnd()
10318 
 
10319 
  def write(self, oprot):
10320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10322 
      return
10323 
    oprot.writeStructBegin('getOrderList_args')
10324 
    if self.order_ids is not None:
10325 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10326 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10327 
      for iter174 in self.order_ids:
10328 
        oprot.writeI64(iter174)
4999 phani.kuma 10329 
      oprot.writeListEnd()
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
10349 
class getOrderList_result:
10350 
  """
10351 
  Attributes:
10352 
   - success
10353 
  """
10354 
 
10355 
  thrift_spec = (
10356 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10357 
  )
10358 
 
10359 
  def __init__(self, success=None,):
10360 
    self.success = success
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:
10372 
        if ftype == TType.LIST:
10373 
          self.success = []
5031 varun.gupt 10374 
          (_etype178, _size175) = iprot.readListBegin()
10375 
          for _i179 in xrange(_size175):
10376 
            _elem180 = Order()
10377 
            _elem180.read(iprot)
10378 
            self.success.append(_elem180)
4999 phani.kuma 10379 
          iprot.readListEnd()
10380 
        else:
10381 
          iprot.skip(ftype)
10382 
      else:
10383 
        iprot.skip(ftype)
10384 
      iprot.readFieldEnd()
10385 
    iprot.readStructEnd()
10386 
 
10387 
  def write(self, oprot):
10388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10390 
      return
10391 
    oprot.writeStructBegin('getOrderList_result')
10392 
    if self.success is not None:
10393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10394 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10395 
      for iter181 in self.success:
10396 
        iter181.write(oprot)
4999 phani.kuma 10397 
      oprot.writeListEnd()
10398 
      oprot.writeFieldEnd()
10399 
    oprot.writeFieldStop()
10400 
    oprot.writeStructEnd()
10401 
 
10402 
  def validate(self):
10403 
    return
10404 
 
10405 
 
10406 
  def __repr__(self):
10407 
    L = ['%s=%r' % (key, value)
10408 
      for key, value in self.__dict__.iteritems()]
10409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10410 
 
10411 
  def __eq__(self, other):
10412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10413 
 
10414 
  def __ne__(self, other):
10415 
    return not (self == other)
10416 
 
5386 phani.kuma 10417 
class getOrderListForVendor_args:
10418 
  """
10419 
  Attributes:
10420 
   - order_ids
10421 
   - vendorId
10422 
  """
10423 
 
10424 
  thrift_spec = (
10425 
    None, # 0
10426 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10427 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10428 
  )
10429 
 
10430 
  def __init__(self, order_ids=None, vendorId=None,):
10431 
    self.order_ids = order_ids
10432 
    self.vendorId = vendorId
10433 
 
10434 
  def read(self, iprot):
10435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10437 
      return
10438 
    iprot.readStructBegin()
10439 
    while True:
10440 
      (fname, ftype, fid) = iprot.readFieldBegin()
10441 
      if ftype == TType.STOP:
10442 
        break
10443 
      if fid == 1:
10444 
        if ftype == TType.LIST:
10445 
          self.order_ids = []
10446 
          (_etype185, _size182) = iprot.readListBegin()
10447 
          for _i186 in xrange(_size182):
10448 
            _elem187 = iprot.readI64();
10449 
            self.order_ids.append(_elem187)
10450 
          iprot.readListEnd()
10451 
        else:
10452 
          iprot.skip(ftype)
10453 
      elif fid == 2:
10454 
        if ftype == TType.I64:
10455 
          self.vendorId = iprot.readI64();
10456 
        else:
10457 
          iprot.skip(ftype)
10458 
      else:
10459 
        iprot.skip(ftype)
10460 
      iprot.readFieldEnd()
10461 
    iprot.readStructEnd()
10462 
 
10463 
  def write(self, oprot):
10464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10466 
      return
10467 
    oprot.writeStructBegin('getOrderListForVendor_args')
10468 
    if self.order_ids is not None:
10469 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10470 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10471 
      for iter188 in self.order_ids:
10472 
        oprot.writeI64(iter188)
10473 
      oprot.writeListEnd()
10474 
      oprot.writeFieldEnd()
10475 
    if self.vendorId is not None:
10476 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10477 
      oprot.writeI64(self.vendorId)
10478 
      oprot.writeFieldEnd()
10479 
    oprot.writeFieldStop()
10480 
    oprot.writeStructEnd()
10481 
 
10482 
  def validate(self):
10483 
    return
10484 
 
10485 
 
10486 
  def __repr__(self):
10487 
    L = ['%s=%r' % (key, value)
10488 
      for key, value in self.__dict__.iteritems()]
10489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10490 
 
10491 
  def __eq__(self, other):
10492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10493 
 
10494 
  def __ne__(self, other):
10495 
    return not (self == other)
10496 
 
10497 
class getOrderListForVendor_result:
10498 
  """
10499 
  Attributes:
10500 
   - success
10501 
  """
10502 
 
10503 
  thrift_spec = (
10504 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10505 
  )
10506 
 
10507 
  def __init__(self, success=None,):
10508 
    self.success = success
10509 
 
10510 
  def read(self, iprot):
10511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10513 
      return
10514 
    iprot.readStructBegin()
10515 
    while True:
10516 
      (fname, ftype, fid) = iprot.readFieldBegin()
10517 
      if ftype == TType.STOP:
10518 
        break
10519 
      if fid == 0:
10520 
        if ftype == TType.LIST:
10521 
          self.success = []
10522 
          (_etype192, _size189) = iprot.readListBegin()
10523 
          for _i193 in xrange(_size189):
10524 
            _elem194 = Order()
10525 
            _elem194.read(iprot)
10526 
            self.success.append(_elem194)
10527 
          iprot.readListEnd()
10528 
        else:
10529 
          iprot.skip(ftype)
10530 
      else:
10531 
        iprot.skip(ftype)
10532 
      iprot.readFieldEnd()
10533 
    iprot.readStructEnd()
10534 
 
10535 
  def write(self, oprot):
10536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10538 
      return
10539 
    oprot.writeStructBegin('getOrderListForVendor_result')
10540 
    if self.success is not None:
10541 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10542 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10543 
      for iter195 in self.success:
10544 
        iter195.write(oprot)
10545 
      oprot.writeListEnd()
10546 
      oprot.writeFieldEnd()
10547 
    oprot.writeFieldStop()
10548 
    oprot.writeStructEnd()
10549 
 
10550 
  def validate(self):
10551 
    return
10552 
 
10553 
 
10554 
  def __repr__(self):
10555 
    L = ['%s=%r' % (key, value)
10556 
      for key, value in self.__dict__.iteritems()]
10557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10558 
 
10559 
  def __eq__(self, other):
10560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10561 
 
10562 
  def __ne__(self, other):
10563 
    return not (self == other)
10564 
 
3064 chandransh 10565 
class getOrderForCustomer_args:
94 ashish 10566 
  """
10567 
  Attributes:
3064 chandransh 10568 
   - orderId
483 rajveer 10569 
   - customerId
94 ashish 10570 
  """
10571 
 
10572 
  thrift_spec = (
10573 
    None, # 0
3064 chandransh 10574 
    (1, TType.I64, 'orderId', None, None, ), # 1
10575 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10576 
  )
10577 
 
3064 chandransh 10578 
  def __init__(self, orderId=None, customerId=None,):
10579 
    self.orderId = orderId
483 rajveer 10580 
    self.customerId = customerId
94 ashish 10581 
 
10582 
  def read(self, iprot):
10583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10585 
      return
10586 
    iprot.readStructBegin()
10587 
    while True:
10588 
      (fname, ftype, fid) = iprot.readFieldBegin()
10589 
      if ftype == TType.STOP:
10590 
        break
10591 
      if fid == 1:
10592 
        if ftype == TType.I64:
3064 chandransh 10593 
          self.orderId = iprot.readI64();
94 ashish 10594 
        else:
10595 
          iprot.skip(ftype)
10596 
      elif fid == 2:
10597 
        if ftype == TType.I64:
3064 chandransh 10598 
          self.customerId = iprot.readI64();
94 ashish 10599 
        else:
10600 
          iprot.skip(ftype)
10601 
      else:
10602 
        iprot.skip(ftype)
10603 
      iprot.readFieldEnd()
10604 
    iprot.readStructEnd()
10605 
 
10606 
  def write(self, oprot):
10607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10609 
      return
3064 chandransh 10610 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10611 
    if self.orderId is not None:
3064 chandransh 10612 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10613 
      oprot.writeI64(self.orderId)
10614 
      oprot.writeFieldEnd()
3431 rajveer 10615 
    if self.customerId is not None:
3064 chandransh 10616 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10617 
      oprot.writeI64(self.customerId)
94 ashish 10618 
      oprot.writeFieldEnd()
10619 
    oprot.writeFieldStop()
10620 
    oprot.writeStructEnd()
10621 
 
3431 rajveer 10622 
  def validate(self):
10623 
    return
10624 
 
10625 
 
94 ashish 10626 
  def __repr__(self):
10627 
    L = ['%s=%r' % (key, value)
10628 
      for key, value in self.__dict__.iteritems()]
10629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10630 
 
10631 
  def __eq__(self, other):
10632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10633 
 
10634 
  def __ne__(self, other):
10635 
    return not (self == other)
10636 
 
3064 chandransh 10637 
class getOrderForCustomer_result:
94 ashish 10638 
  """
10639 
  Attributes:
10640 
   - success
10641 
   - ex
10642 
  """
10643 
 
10644 
  thrift_spec = (
3064 chandransh 10645 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10647 
  )
10648 
 
10649 
  def __init__(self, success=None, ex=None,):
10650 
    self.success = success
10651 
    self.ex = ex
10652 
 
10653 
  def read(self, iprot):
10654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10656 
      return
10657 
    iprot.readStructBegin()
10658 
    while True:
10659 
      (fname, ftype, fid) = iprot.readFieldBegin()
10660 
      if ftype == TType.STOP:
10661 
        break
10662 
      if fid == 0:
3064 chandransh 10663 
        if ftype == TType.STRUCT:
10664 
          self.success = Order()
10665 
          self.success.read(iprot)
94 ashish 10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      elif fid == 1:
10669 
        if ftype == TType.STRUCT:
10670 
          self.ex = TransactionServiceException()
10671 
          self.ex.read(iprot)
10672 
        else:
10673 
          iprot.skip(ftype)
10674 
      else:
10675 
        iprot.skip(ftype)
10676 
      iprot.readFieldEnd()
10677 
    iprot.readStructEnd()
10678 
 
10679 
  def write(self, oprot):
10680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10682 
      return
3064 chandransh 10683 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10684 
    if self.success is not None:
3064 chandransh 10685 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10686 
      self.success.write(oprot)
94 ashish 10687 
      oprot.writeFieldEnd()
3431 rajveer 10688 
    if self.ex is not None:
94 ashish 10689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10690 
      self.ex.write(oprot)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
3431 rajveer 10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
94 ashish 10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
3064 chandransh 10710 
class getAlerts_args:
94 ashish 10711 
  """
10712 
  Attributes:
4394 rajveer 10713 
   - type
4444 rajveer 10714 
   - warehouseId
4394 rajveer 10715 
   - status
10716 
   - timestamp
94 ashish 10717 
  """
10718 
 
10719 
  thrift_spec = (
10720 
    None, # 0
4394 rajveer 10721 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10722 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10723 
    (3, TType.I64, 'status', None, None, ), # 3
10724 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10725 
  )
10726 
 
4444 rajveer 10727 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10728 
    self.type = type
4444 rajveer 10729 
    self.warehouseId = warehouseId
4394 rajveer 10730 
    self.status = status
10731 
    self.timestamp = timestamp
94 ashish 10732 
 
10733 
  def read(self, iprot):
10734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10736 
      return
10737 
    iprot.readStructBegin()
10738 
    while True:
10739 
      (fname, ftype, fid) = iprot.readFieldBegin()
10740 
      if ftype == TType.STOP:
10741 
        break
10742 
      if fid == 1:
3064 chandransh 10743 
        if ftype == TType.I64:
4394 rajveer 10744 
          self.type = iprot.readI64();
94 ashish 10745 
        else:
10746 
          iprot.skip(ftype)
3064 chandransh 10747 
      elif fid == 2:
4394 rajveer 10748 
        if ftype == TType.I64:
4444 rajveer 10749 
          self.warehouseId = iprot.readI64();
3064 chandransh 10750 
        else:
10751 
          iprot.skip(ftype)
4394 rajveer 10752 
      elif fid == 3:
10753 
        if ftype == TType.I64:
4444 rajveer 10754 
          self.status = iprot.readI64();
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      elif fid == 4:
10758 
        if ftype == TType.I64:
4394 rajveer 10759 
          self.timestamp = iprot.readI64();
10760 
        else:
10761 
          iprot.skip(ftype)
94 ashish 10762 
      else:
10763 
        iprot.skip(ftype)
10764 
      iprot.readFieldEnd()
10765 
    iprot.readStructEnd()
10766 
 
10767 
  def write(self, oprot):
10768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10770 
      return
3064 chandransh 10771 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10772 
    if self.type is not None:
10773 
      oprot.writeFieldBegin('type', TType.I64, 1)
10774 
      oprot.writeI64(self.type)
94 ashish 10775 
      oprot.writeFieldEnd()
4444 rajveer 10776 
    if self.warehouseId is not None:
10777 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10778 
      oprot.writeI64(self.warehouseId)
10779 
      oprot.writeFieldEnd()
4394 rajveer 10780 
    if self.status is not None:
4444 rajveer 10781 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10782 
      oprot.writeI64(self.status)
3064 chandransh 10783 
      oprot.writeFieldEnd()
4394 rajveer 10784 
    if self.timestamp is not None:
4444 rajveer 10785 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10786 
      oprot.writeI64(self.timestamp)
10787 
      oprot.writeFieldEnd()
94 ashish 10788 
    oprot.writeFieldStop()
10789 
    oprot.writeStructEnd()
10790 
 
3431 rajveer 10791 
  def validate(self):
10792 
    return
10793 
 
10794 
 
94 ashish 10795 
  def __repr__(self):
10796 
    L = ['%s=%r' % (key, value)
10797 
      for key, value in self.__dict__.iteritems()]
10798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10799 
 
10800 
  def __eq__(self, other):
10801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10802 
 
10803 
  def __ne__(self, other):
10804 
    return not (self == other)
10805 
 
3064 chandransh 10806 
class getAlerts_result:
94 ashish 10807 
  """
10808 
  Attributes:
10809 
   - success
10810 
  """
10811 
 
10812 
  thrift_spec = (
3064 chandransh 10813 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10814 
  )
10815 
 
3064 chandransh 10816 
  def __init__(self, success=None,):
94 ashish 10817 
    self.success = success
10818 
 
10819 
  def read(self, iprot):
10820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10822 
      return
10823 
    iprot.readStructBegin()
10824 
    while True:
10825 
      (fname, ftype, fid) = iprot.readFieldBegin()
10826 
      if ftype == TType.STOP:
10827 
        break
10828 
      if fid == 0:
3064 chandransh 10829 
        if ftype == TType.LIST:
10830 
          self.success = []
5386 phani.kuma 10831 
          (_etype199, _size196) = iprot.readListBegin()
10832 
          for _i200 in xrange(_size196):
10833 
            _elem201 = Alert()
10834 
            _elem201.read(iprot)
10835 
            self.success.append(_elem201)
3064 chandransh 10836 
          iprot.readListEnd()
94 ashish 10837 
        else:
10838 
          iprot.skip(ftype)
10839 
      else:
10840 
        iprot.skip(ftype)
10841 
      iprot.readFieldEnd()
10842 
    iprot.readStructEnd()
10843 
 
10844 
  def write(self, oprot):
10845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10847 
      return
3064 chandransh 10848 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10849 
    if self.success is not None:
3064 chandransh 10850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10852 
      for iter202 in self.success:
10853 
        iter202.write(oprot)
3064 chandransh 10854 
      oprot.writeListEnd()
94 ashish 10855 
      oprot.writeFieldEnd()
10856 
    oprot.writeFieldStop()
10857 
    oprot.writeStructEnd()
10858 
 
3431 rajveer 10859 
  def validate(self):
10860 
    return
10861 
 
10862 
 
94 ashish 10863 
  def __repr__(self):
10864 
    L = ['%s=%r' % (key, value)
10865 
      for key, value in self.__dict__.iteritems()]
10866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10867 
 
10868 
  def __eq__(self, other):
10869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10870 
 
10871 
  def __ne__(self, other):
10872 
    return not (self == other)
10873 
 
4394 rajveer 10874 
class addAlert_args:
94 ashish 10875 
  """
10876 
  Attributes:
3064 chandransh 10877 
   - type
4444 rajveer 10878 
   - warehouseId
4394 rajveer 10879 
   - description
94 ashish 10880 
  """
10881 
 
10882 
  thrift_spec = (
10883 
    None, # 0
4394 rajveer 10884 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10885 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10886 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10887 
  )
10888 
 
4444 rajveer 10889 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10890 
    self.type = type
4444 rajveer 10891 
    self.warehouseId = warehouseId
4394 rajveer 10892 
    self.description = description
94 ashish 10893 
 
10894 
  def read(self, iprot):
10895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10897 
      return
10898 
    iprot.readStructBegin()
10899 
    while True:
10900 
      (fname, ftype, fid) = iprot.readFieldBegin()
10901 
      if ftype == TType.STOP:
10902 
        break
10903 
      if fid == 1:
10904 
        if ftype == TType.I64:
4394 rajveer 10905 
          self.type = iprot.readI64();
94 ashish 10906 
        else:
10907 
          iprot.skip(ftype)
3064 chandransh 10908 
      elif fid == 2:
4444 rajveer 10909 
        if ftype == TType.I64:
10910 
          self.warehouseId = iprot.readI64();
10911 
        else:
10912 
          iprot.skip(ftype)
10913 
      elif fid == 3:
3064 chandransh 10914 
        if ftype == TType.STRING:
4394 rajveer 10915 
          self.description = iprot.readString();
3064 chandransh 10916 
        else:
10917 
          iprot.skip(ftype)
94 ashish 10918 
      else:
10919 
        iprot.skip(ftype)
10920 
      iprot.readFieldEnd()
10921 
    iprot.readStructEnd()
10922 
 
10923 
  def write(self, oprot):
10924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10926 
      return
4394 rajveer 10927 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10928 
    if self.type is not None:
4394 rajveer 10929 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10930 
      oprot.writeI64(self.type)
10931 
      oprot.writeFieldEnd()
4444 rajveer 10932 
    if self.warehouseId is not None:
10933 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10934 
      oprot.writeI64(self.warehouseId)
10935 
      oprot.writeFieldEnd()
4394 rajveer 10936 
    if self.description is not None:
4444 rajveer 10937 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10938 
      oprot.writeString(self.description)
3064 chandransh 10939 
      oprot.writeFieldEnd()
94 ashish 10940 
    oprot.writeFieldStop()
10941 
    oprot.writeStructEnd()
10942 
 
3431 rajveer 10943 
  def validate(self):
10944 
    return
10945 
 
10946 
 
94 ashish 10947 
  def __repr__(self):
10948 
    L = ['%s=%r' % (key, value)
10949 
      for key, value in self.__dict__.iteritems()]
10950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10951 
 
10952 
  def __eq__(self, other):
10953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10954 
 
10955 
  def __ne__(self, other):
10956 
    return not (self == other)
10957 
 
4394 rajveer 10958 
class addAlert_result:
3064 chandransh 10959 
 
10960 
  thrift_spec = (
10961 
  )
10962 
 
10963 
  def read(self, iprot):
10964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10966 
      return
10967 
    iprot.readStructBegin()
10968 
    while True:
10969 
      (fname, ftype, fid) = iprot.readFieldBegin()
10970 
      if ftype == TType.STOP:
10971 
        break
10972 
      else:
10973 
        iprot.skip(ftype)
10974 
      iprot.readFieldEnd()
10975 
    iprot.readStructEnd()
10976 
 
10977 
  def write(self, oprot):
10978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10980 
      return
4394 rajveer 10981 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
3431 rajveer 10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
3064 chandransh 10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
4444 rajveer 11000 
class markAlertsAsSeen_args:
11001 
  """
11002 
  Attributes:
11003 
   - warehouseId
11004 
  """
11005 
 
11006 
  thrift_spec = (
11007 
    None, # 0
11008 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11009 
  )
11010 
 
11011 
  def __init__(self, warehouseId=None,):
11012 
    self.warehouseId = warehouseId
11013 
 
11014 
  def read(self, iprot):
11015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11017 
      return
11018 
    iprot.readStructBegin()
11019 
    while True:
11020 
      (fname, ftype, fid) = iprot.readFieldBegin()
11021 
      if ftype == TType.STOP:
11022 
        break
11023 
      if fid == 1:
11024 
        if ftype == TType.I64:
11025 
          self.warehouseId = iprot.readI64();
11026 
        else:
11027 
          iprot.skip(ftype)
11028 
      else:
11029 
        iprot.skip(ftype)
11030 
      iprot.readFieldEnd()
11031 
    iprot.readStructEnd()
11032 
 
11033 
  def write(self, oprot):
11034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11036 
      return
11037 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11038 
    if self.warehouseId is not None:
11039 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11040 
      oprot.writeI64(self.warehouseId)
11041 
      oprot.writeFieldEnd()
11042 
    oprot.writeFieldStop()
11043 
    oprot.writeStructEnd()
11044 
 
11045 
  def validate(self):
11046 
    return
11047 
 
11048 
 
11049 
  def __repr__(self):
11050 
    L = ['%s=%r' % (key, value)
11051 
      for key, value in self.__dict__.iteritems()]
11052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11053 
 
11054 
  def __eq__(self, other):
11055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11056 
 
11057 
  def __ne__(self, other):
11058 
    return not (self == other)
11059 
 
11060 
class markAlertsAsSeen_result:
11061 
 
11062 
  thrift_spec = (
11063 
  )
11064 
 
11065 
  def read(self, iprot):
11066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11068 
      return
11069 
    iprot.readStructBegin()
11070 
    while True:
11071 
      (fname, ftype, fid) = iprot.readFieldBegin()
11072 
      if ftype == TType.STOP:
11073 
        break
11074 
      else:
11075 
        iprot.skip(ftype)
11076 
      iprot.readFieldEnd()
11077 
    iprot.readStructEnd()
11078 
 
11079 
  def write(self, oprot):
11080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11082 
      return
11083 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11084 
    oprot.writeFieldStop()
11085 
    oprot.writeStructEnd()
11086 
 
11087 
  def validate(self):
11088 
    return
11089 
 
11090 
 
11091 
  def __repr__(self):
11092 
    L = ['%s=%r' % (key, value)
11093 
      for key, value in self.__dict__.iteritems()]
11094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11095 
 
11096 
  def __eq__(self, other):
11097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11098 
 
11099 
  def __ne__(self, other):
11100 
    return not (self == other)
11101 
 
3064 chandransh 11102 
class getValidOrderCount_args:
11103 
 
11104 
  thrift_spec = (
11105 
  )
11106 
 
11107 
  def read(self, iprot):
11108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11110 
      return
11111 
    iprot.readStructBegin()
11112 
    while True:
11113 
      (fname, ftype, fid) = iprot.readFieldBegin()
11114 
      if ftype == TType.STOP:
11115 
        break
11116 
      else:
11117 
        iprot.skip(ftype)
11118 
      iprot.readFieldEnd()
11119 
    iprot.readStructEnd()
11120 
 
11121 
  def write(self, oprot):
11122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11124 
      return
11125 
    oprot.writeStructBegin('getValidOrderCount_args')
11126 
    oprot.writeFieldStop()
11127 
    oprot.writeStructEnd()
11128 
 
3431 rajveer 11129 
  def validate(self):
11130 
    return
11131 
 
11132 
 
3064 chandransh 11133 
  def __repr__(self):
11134 
    L = ['%s=%r' % (key, value)
11135 
      for key, value in self.__dict__.iteritems()]
11136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11137 
 
11138 
  def __eq__(self, other):
11139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11140 
 
11141 
  def __ne__(self, other):
11142 
    return not (self == other)
11143 
 
11144 
class getValidOrderCount_result:
94 ashish 11145 
  """
11146 
  Attributes:
11147 
   - success
11148 
  """
11149 
 
11150 
  thrift_spec = (
3064 chandransh 11151 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11152 
  )
11153 
 
3064 chandransh 11154 
  def __init__(self, success=None,):
94 ashish 11155 
    self.success = success
11156 
 
11157 
  def read(self, iprot):
11158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11160 
      return
11161 
    iprot.readStructBegin()
11162 
    while True:
11163 
      (fname, ftype, fid) = iprot.readFieldBegin()
11164 
      if ftype == TType.STOP:
11165 
        break
11166 
      if fid == 0:
3064 chandransh 11167 
        if ftype == TType.I64:
11168 
          self.success = iprot.readI64();
94 ashish 11169 
        else:
11170 
          iprot.skip(ftype)
11171 
      else:
11172 
        iprot.skip(ftype)
11173 
      iprot.readFieldEnd()
11174 
    iprot.readStructEnd()
11175 
 
11176 
  def write(self, oprot):
11177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11179 
      return
3064 chandransh 11180 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11181 
    if self.success is not None:
3064 chandransh 11182 
      oprot.writeFieldBegin('success', TType.I64, 0)
11183 
      oprot.writeI64(self.success)
94 ashish 11184 
      oprot.writeFieldEnd()
11185 
    oprot.writeFieldStop()
11186 
    oprot.writeStructEnd()
11187 
 
3431 rajveer 11188 
  def validate(self):
11189 
    return
11190 
 
11191 
 
94 ashish 11192 
  def __repr__(self):
11193 
    L = ['%s=%r' % (key, value)
11194 
      for key, value in self.__dict__.iteritems()]
11195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11196 
 
11197 
  def __eq__(self, other):
11198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11199 
 
11200 
  def __ne__(self, other):
11201 
    return not (self == other)
11202 
 
3064 chandransh 11203 
class getNoOfCustomersWithSuccessfulTransaction_args:
11204 
 
11205 
  thrift_spec = (
11206 
  )
11207 
 
11208 
  def read(self, iprot):
11209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11211 
      return
11212 
    iprot.readStructBegin()
11213 
    while True:
11214 
      (fname, ftype, fid) = iprot.readFieldBegin()
11215 
      if ftype == TType.STOP:
11216 
        break
11217 
      else:
11218 
        iprot.skip(ftype)
11219 
      iprot.readFieldEnd()
11220 
    iprot.readStructEnd()
11221 
 
11222 
  def write(self, oprot):
11223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11225 
      return
11226 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
3431 rajveer 11230 
  def validate(self):
11231 
    return
11232 
 
11233 
 
3064 chandransh 11234 
  def __repr__(self):
11235 
    L = ['%s=%r' % (key, value)
11236 
      for key, value in self.__dict__.iteritems()]
11237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11238 
 
11239 
  def __eq__(self, other):
11240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11241 
 
11242 
  def __ne__(self, other):
11243 
    return not (self == other)
11244 
 
11245 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11246 
  """
11247 
  Attributes:
3064 chandransh 11248 
   - success
94 ashish 11249 
  """
11250 
 
11251 
  thrift_spec = (
3064 chandransh 11252 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11253 
  )
11254 
 
3064 chandransh 11255 
  def __init__(self, success=None,):
11256 
    self.success = success
94 ashish 11257 
 
11258 
  def read(self, iprot):
11259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11261 
      return
11262 
    iprot.readStructBegin()
11263 
    while True:
11264 
      (fname, ftype, fid) = iprot.readFieldBegin()
11265 
      if ftype == TType.STOP:
11266 
        break
3064 chandransh 11267 
      if fid == 0:
94 ashish 11268 
        if ftype == TType.I64:
3064 chandransh 11269 
          self.success = iprot.readI64();
94 ashish 11270 
        else:
11271 
          iprot.skip(ftype)
11272 
      else:
11273 
        iprot.skip(ftype)
11274 
      iprot.readFieldEnd()
11275 
    iprot.readStructEnd()
11276 
 
11277 
  def write(self, oprot):
11278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11280 
      return
3064 chandransh 11281 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11282 
    if self.success is not None:
3064 chandransh 11283 
      oprot.writeFieldBegin('success', TType.I64, 0)
11284 
      oprot.writeI64(self.success)
94 ashish 11285 
      oprot.writeFieldEnd()
11286 
    oprot.writeFieldStop()
11287 
    oprot.writeStructEnd()
11288 
 
3431 rajveer 11289 
  def validate(self):
11290 
    return
11291 
 
11292 
 
94 ashish 11293 
  def __repr__(self):
11294 
    L = ['%s=%r' % (key, value)
11295 
      for key, value in self.__dict__.iteritems()]
11296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11297 
 
11298 
  def __eq__(self, other):
11299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11300 
 
11301 
  def __ne__(self, other):
11302 
    return not (self == other)
11303 
 
3064 chandransh 11304 
class getValidOrdersAmountRange_args:
11305 
 
11306 
  thrift_spec = (
11307 
  )
11308 
 
11309 
  def read(self, iprot):
11310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11312 
      return
11313 
    iprot.readStructBegin()
11314 
    while True:
11315 
      (fname, ftype, fid) = iprot.readFieldBegin()
11316 
      if ftype == TType.STOP:
11317 
        break
11318 
      else:
11319 
        iprot.skip(ftype)
11320 
      iprot.readFieldEnd()
11321 
    iprot.readStructEnd()
11322 
 
11323 
  def write(self, oprot):
11324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11326 
      return
11327 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11328 
    oprot.writeFieldStop()
11329 
    oprot.writeStructEnd()
11330 
 
3431 rajveer 11331 
  def validate(self):
11332 
    return
11333 
 
11334 
 
3064 chandransh 11335 
  def __repr__(self):
11336 
    L = ['%s=%r' % (key, value)
11337 
      for key, value in self.__dict__.iteritems()]
11338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11339 
 
11340 
  def __eq__(self, other):
11341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11342 
 
11343 
  def __ne__(self, other):
11344 
    return not (self == other)
11345 
 
11346 
class getValidOrdersAmountRange_result:
94 ashish 11347 
  """
11348 
  Attributes:
11349 
   - success
11350 
  """
11351 
 
11352 
  thrift_spec = (
3064 chandransh 11353 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11354 
  )
11355 
 
3064 chandransh 11356 
  def __init__(self, success=None,):
94 ashish 11357 
    self.success = success
11358 
 
11359 
  def read(self, iprot):
11360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11362 
      return
11363 
    iprot.readStructBegin()
11364 
    while True:
11365 
      (fname, ftype, fid) = iprot.readFieldBegin()
11366 
      if ftype == TType.STOP:
11367 
        break
11368 
      if fid == 0:
483 rajveer 11369 
        if ftype == TType.LIST:
11370 
          self.success = []
5386 phani.kuma 11371 
          (_etype206, _size203) = iprot.readListBegin()
11372 
          for _i207 in xrange(_size203):
11373 
            _elem208 = iprot.readDouble();
11374 
            self.success.append(_elem208)
483 rajveer 11375 
          iprot.readListEnd()
94 ashish 11376 
        else:
11377 
          iprot.skip(ftype)
11378 
      else:
11379 
        iprot.skip(ftype)
11380 
      iprot.readFieldEnd()
11381 
    iprot.readStructEnd()
11382 
 
11383 
  def write(self, oprot):
11384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11386 
      return
3064 chandransh 11387 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11388 
    if self.success is not None:
483 rajveer 11389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11390 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11391 
      for iter209 in self.success:
11392 
        oprot.writeDouble(iter209)
483 rajveer 11393 
      oprot.writeListEnd()
94 ashish 11394 
      oprot.writeFieldEnd()
11395 
    oprot.writeFieldStop()
11396 
    oprot.writeStructEnd()
11397 
 
3431 rajveer 11398 
  def validate(self):
11399 
    return
11400 
 
11401 
 
94 ashish 11402 
  def __repr__(self):
11403 
    L = ['%s=%r' % (key, value)
11404 
      for key, value in self.__dict__.iteritems()]
11405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11406 
 
11407 
  def __eq__(self, other):
11408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11409 
 
11410 
  def __ne__(self, other):
11411 
    return not (self == other)
11412 
 
3064 chandransh 11413 
class getValidOrders_args:
1528 ankur.sing 11414 
  """
11415 
  Attributes:
3064 chandransh 11416 
   - limit
1528 ankur.sing 11417 
  """
11418 
 
11419 
  thrift_spec = (
11420 
    None, # 0
3064 chandransh 11421 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11422 
  )
11423 
 
3064 chandransh 11424 
  def __init__(self, limit=None,):
11425 
    self.limit = limit
1528 ankur.sing 11426 
 
11427 
  def read(self, iprot):
11428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11430 
      return
11431 
    iprot.readStructBegin()
11432 
    while True:
11433 
      (fname, ftype, fid) = iprot.readFieldBegin()
11434 
      if ftype == TType.STOP:
11435 
        break
11436 
      if fid == 1:
11437 
        if ftype == TType.I64:
3064 chandransh 11438 
          self.limit = iprot.readI64();
1528 ankur.sing 11439 
        else:
11440 
          iprot.skip(ftype)
11441 
      else:
11442 
        iprot.skip(ftype)
11443 
      iprot.readFieldEnd()
11444 
    iprot.readStructEnd()
11445 
 
11446 
  def write(self, oprot):
11447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11449 
      return
3064 chandransh 11450 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11451 
    if self.limit is not None:
3064 chandransh 11452 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11453 
      oprot.writeI64(self.limit)
1528 ankur.sing 11454 
      oprot.writeFieldEnd()
11455 
    oprot.writeFieldStop()
11456 
    oprot.writeStructEnd()
11457 
 
3431 rajveer 11458 
  def validate(self):
11459 
    return
11460 
 
11461 
 
1528 ankur.sing 11462 
  def __repr__(self):
11463 
    L = ['%s=%r' % (key, value)
11464 
      for key, value in self.__dict__.iteritems()]
11465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11466 
 
11467 
  def __eq__(self, other):
11468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11469 
 
11470 
  def __ne__(self, other):
11471 
    return not (self == other)
11472 
 
3064 chandransh 11473 
class getValidOrders_result:
1528 ankur.sing 11474 
  """
11475 
  Attributes:
11476 
   - success
11477 
  """
11478 
 
11479 
  thrift_spec = (
3064 chandransh 11480 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11481 
  )
11482 
 
3064 chandransh 11483 
  def __init__(self, success=None,):
1528 ankur.sing 11484 
    self.success = success
11485 
 
11486 
  def read(self, iprot):
11487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11489 
      return
11490 
    iprot.readStructBegin()
11491 
    while True:
11492 
      (fname, ftype, fid) = iprot.readFieldBegin()
11493 
      if ftype == TType.STOP:
11494 
        break
11495 
      if fid == 0:
3064 chandransh 11496 
        if ftype == TType.LIST:
11497 
          self.success = []
5386 phani.kuma 11498 
          (_etype213, _size210) = iprot.readListBegin()
11499 
          for _i214 in xrange(_size210):
11500 
            _elem215 = Order()
11501 
            _elem215.read(iprot)
11502 
            self.success.append(_elem215)
3064 chandransh 11503 
          iprot.readListEnd()
1528 ankur.sing 11504 
        else:
11505 
          iprot.skip(ftype)
11506 
      else:
11507 
        iprot.skip(ftype)
11508 
      iprot.readFieldEnd()
11509 
    iprot.readStructEnd()
11510 
 
11511 
  def write(self, oprot):
11512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11514 
      return
3064 chandransh 11515 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11516 
    if self.success is not None:
3064 chandransh 11517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11519 
      for iter216 in self.success:
11520 
        iter216.write(oprot)
3064 chandransh 11521 
      oprot.writeListEnd()
1528 ankur.sing 11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
1528 ankur.sing 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
1220 chandransh 11541 
class batchOrders_args:
11542 
  """
11543 
  Attributes:
11544 
   - warehouseId
11545 
  """
11546 
 
11547 
  thrift_spec = (
11548 
    None, # 0
11549 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11550 
  )
11551 
 
11552 
  def __init__(self, warehouseId=None,):
11553 
    self.warehouseId = warehouseId
11554 
 
11555 
  def read(self, iprot):
11556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11558 
      return
11559 
    iprot.readStructBegin()
11560 
    while True:
11561 
      (fname, ftype, fid) = iprot.readFieldBegin()
11562 
      if ftype == TType.STOP:
11563 
        break
11564 
      if fid == 1:
11565 
        if ftype == TType.I64:
11566 
          self.warehouseId = iprot.readI64();
11567 
        else:
11568 
          iprot.skip(ftype)
11569 
      else:
11570 
        iprot.skip(ftype)
11571 
      iprot.readFieldEnd()
11572 
    iprot.readStructEnd()
11573 
 
11574 
  def write(self, oprot):
11575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11577 
      return
11578 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11579 
    if self.warehouseId is not None:
1220 chandransh 11580 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11581 
      oprot.writeI64(self.warehouseId)
11582 
      oprot.writeFieldEnd()
11583 
    oprot.writeFieldStop()
11584 
    oprot.writeStructEnd()
11585 
 
3431 rajveer 11586 
  def validate(self):
11587 
    return
11588 
 
11589 
 
1220 chandransh 11590 
  def __repr__(self):
11591 
    L = ['%s=%r' % (key, value)
11592 
      for key, value in self.__dict__.iteritems()]
11593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11594 
 
11595 
  def __eq__(self, other):
11596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11597 
 
11598 
  def __ne__(self, other):
11599 
    return not (self == other)
11600 
 
11601 
class batchOrders_result:
11602 
  """
11603 
  Attributes:
11604 
   - success
11605 
   - ex
11606 
  """
11607 
 
11608 
  thrift_spec = (
11609 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11611 
  )
11612 
 
11613 
  def __init__(self, success=None, ex=None,):
11614 
    self.success = success
11615 
    self.ex = ex
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 0:
11627 
        if ftype == TType.LIST:
11628 
          self.success = []
5386 phani.kuma 11629 
          (_etype220, _size217) = iprot.readListBegin()
11630 
          for _i221 in xrange(_size217):
11631 
            _elem222 = Order()
11632 
            _elem222.read(iprot)
11633 
            self.success.append(_elem222)
1220 chandransh 11634 
          iprot.readListEnd()
11635 
        else:
11636 
          iprot.skip(ftype)
11637 
      elif fid == 1:
11638 
        if ftype == TType.STRUCT:
11639 
          self.ex = TransactionServiceException()
11640 
          self.ex.read(iprot)
11641 
        else:
11642 
          iprot.skip(ftype)
11643 
      else:
11644 
        iprot.skip(ftype)
11645 
      iprot.readFieldEnd()
11646 
    iprot.readStructEnd()
11647 
 
11648 
  def write(self, oprot):
11649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11651 
      return
11652 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11653 
    if self.success is not None:
1220 chandransh 11654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11655 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11656 
      for iter223 in self.success:
11657 
        iter223.write(oprot)
1220 chandransh 11658 
      oprot.writeListEnd()
11659 
      oprot.writeFieldEnd()
3431 rajveer 11660 
    if self.ex is not None:
1220 chandransh 11661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11662 
      self.ex.write(oprot)
11663 
      oprot.writeFieldEnd()
11664 
    oprot.writeFieldStop()
11665 
    oprot.writeStructEnd()
11666 
 
3431 rajveer 11667 
  def validate(self):
11668 
    return
11669 
 
11670 
 
1220 chandransh 11671 
  def __repr__(self):
11672 
    L = ['%s=%r' % (key, value)
11673 
      for key, value in self.__dict__.iteritems()]
11674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11675 
 
11676 
  def __eq__(self, other):
11677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11678 
 
11679 
  def __ne__(self, other):
11680 
    return not (self == other)
11681 
 
1208 chandransh 11682 
class markOrderAsOutOfStock_args:
11683 
  """
11684 
  Attributes:
11685 
   - orderId
11686 
  """
11687 
 
11688 
  thrift_spec = (
11689 
    None, # 0
11690 
    (1, TType.I64, 'orderId', None, None, ), # 1
11691 
  )
11692 
 
11693 
  def __init__(self, orderId=None,):
11694 
    self.orderId = orderId
11695 
 
11696 
  def read(self, iprot):
11697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11699 
      return
11700 
    iprot.readStructBegin()
11701 
    while True:
11702 
      (fname, ftype, fid) = iprot.readFieldBegin()
11703 
      if ftype == TType.STOP:
11704 
        break
11705 
      if fid == 1:
11706 
        if ftype == TType.I64:
11707 
          self.orderId = iprot.readI64();
11708 
        else:
11709 
          iprot.skip(ftype)
11710 
      else:
11711 
        iprot.skip(ftype)
11712 
      iprot.readFieldEnd()
11713 
    iprot.readStructEnd()
11714 
 
11715 
  def write(self, oprot):
11716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11718 
      return
11719 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11720 
    if self.orderId is not None:
1208 chandransh 11721 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11722 
      oprot.writeI64(self.orderId)
11723 
      oprot.writeFieldEnd()
11724 
    oprot.writeFieldStop()
11725 
    oprot.writeStructEnd()
11726 
 
3431 rajveer 11727 
  def validate(self):
11728 
    return
11729 
 
11730 
 
1208 chandransh 11731 
  def __repr__(self):
11732 
    L = ['%s=%r' % (key, value)
11733 
      for key, value in self.__dict__.iteritems()]
11734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11735 
 
11736 
  def __eq__(self, other):
11737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11738 
 
11739 
  def __ne__(self, other):
11740 
    return not (self == other)
11741 
 
11742 
class markOrderAsOutOfStock_result:
11743 
  """
11744 
  Attributes:
11745 
   - success
11746 
   - ex
11747 
  """
11748 
 
11749 
  thrift_spec = (
11750 
    (0, TType.BOOL, 'success', None, None, ), # 0
11751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11752 
  )
11753 
 
11754 
  def __init__(self, success=None, ex=None,):
11755 
    self.success = success
11756 
    self.ex = ex
11757 
 
11758 
  def read(self, iprot):
11759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11761 
      return
11762 
    iprot.readStructBegin()
11763 
    while True:
11764 
      (fname, ftype, fid) = iprot.readFieldBegin()
11765 
      if ftype == TType.STOP:
11766 
        break
11767 
      if fid == 0:
11768 
        if ftype == TType.BOOL:
11769 
          self.success = iprot.readBool();
11770 
        else:
11771 
          iprot.skip(ftype)
11772 
      elif fid == 1:
11773 
        if ftype == TType.STRUCT:
11774 
          self.ex = TransactionServiceException()
11775 
          self.ex.read(iprot)
11776 
        else:
11777 
          iprot.skip(ftype)
11778 
      else:
11779 
        iprot.skip(ftype)
11780 
      iprot.readFieldEnd()
11781 
    iprot.readStructEnd()
11782 
 
11783 
  def write(self, oprot):
11784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11786 
      return
11787 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11788 
    if self.success is not None:
1208 chandransh 11789 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11790 
      oprot.writeBool(self.success)
11791 
      oprot.writeFieldEnd()
3431 rajveer 11792 
    if self.ex is not None:
1208 chandransh 11793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11794 
      self.ex.write(oprot)
11795 
      oprot.writeFieldEnd()
11796 
    oprot.writeFieldStop()
11797 
    oprot.writeStructEnd()
11798 
 
3431 rajveer 11799 
  def validate(self):
11800 
    return
11801 
 
11802 
 
1208 chandransh 11803 
  def __repr__(self):
11804 
    L = ['%s=%r' % (key, value)
11805 
      for key, value in self.__dict__.iteritems()]
11806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11807 
 
11808 
  def __eq__(self, other):
11809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11810 
 
11811 
  def __ne__(self, other):
11812 
    return not (self == other)
11813 
 
3064 chandransh 11814 
class verifyOrder_args:
759 chandransh 11815 
  """
11816 
  Attributes:
3064 chandransh 11817 
   - orderId
759 chandransh 11818 
  """
11819 
 
11820 
  thrift_spec = (
11821 
    None, # 0
3064 chandransh 11822 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11823 
  )
11824 
 
3064 chandransh 11825 
  def __init__(self, orderId=None,):
11826 
    self.orderId = orderId
759 chandransh 11827 
 
11828 
  def read(self, iprot):
11829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11831 
      return
11832 
    iprot.readStructBegin()
11833 
    while True:
11834 
      (fname, ftype, fid) = iprot.readFieldBegin()
11835 
      if ftype == TType.STOP:
11836 
        break
11837 
      if fid == 1:
11838 
        if ftype == TType.I64:
3064 chandransh 11839 
          self.orderId = iprot.readI64();
759 chandransh 11840 
        else:
11841 
          iprot.skip(ftype)
11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
3064 chandransh 11851 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11852 
    if self.orderId is not None:
3064 chandransh 11853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11854 
      oprot.writeI64(self.orderId)
759 chandransh 11855 
      oprot.writeFieldEnd()
11856 
    oprot.writeFieldStop()
11857 
    oprot.writeStructEnd()
11858 
 
3431 rajveer 11859 
  def validate(self):
11860 
    return
11861 
 
11862 
 
759 chandransh 11863 
  def __repr__(self):
11864 
    L = ['%s=%r' % (key, value)
11865 
      for key, value in self.__dict__.iteritems()]
11866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11867 
 
11868 
  def __eq__(self, other):
11869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11870 
 
11871 
  def __ne__(self, other):
11872 
    return not (self == other)
11873 
 
3064 chandransh 11874 
class verifyOrder_result:
759 chandransh 11875 
  """
11876 
  Attributes:
11877 
   - success
11878 
   - ex
11879 
  """
11880 
 
11881 
  thrift_spec = (
11882 
    (0, TType.BOOL, 'success', None, None, ), # 0
11883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11884 
  )
11885 
 
11886 
  def __init__(self, success=None, ex=None,):
11887 
    self.success = success
11888 
    self.ex = ex
11889 
 
11890 
  def read(self, iprot):
11891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11893 
      return
11894 
    iprot.readStructBegin()
11895 
    while True:
11896 
      (fname, ftype, fid) = iprot.readFieldBegin()
11897 
      if ftype == TType.STOP:
11898 
        break
11899 
      if fid == 0:
11900 
        if ftype == TType.BOOL:
11901 
          self.success = iprot.readBool();
11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      elif fid == 1:
11905 
        if ftype == TType.STRUCT:
11906 
          self.ex = TransactionServiceException()
11907 
          self.ex.read(iprot)
11908 
        else:
11909 
          iprot.skip(ftype)
11910 
      else:
11911 
        iprot.skip(ftype)
11912 
      iprot.readFieldEnd()
11913 
    iprot.readStructEnd()
11914 
 
11915 
  def write(self, oprot):
11916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11918 
      return
3064 chandransh 11919 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11920 
    if self.success is not None:
759 chandransh 11921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11922 
      oprot.writeBool(self.success)
11923 
      oprot.writeFieldEnd()
3431 rajveer 11924 
    if self.ex is not None:
759 chandransh 11925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11926 
      self.ex.write(oprot)
11927 
      oprot.writeFieldEnd()
11928 
    oprot.writeFieldStop()
11929 
    oprot.writeStructEnd()
11930 
 
3431 rajveer 11931 
  def validate(self):
11932 
    return
11933 
 
11934 
 
759 chandransh 11935 
  def __repr__(self):
11936 
    L = ['%s=%r' % (key, value)
11937 
      for key, value in self.__dict__.iteritems()]
11938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11939 
 
11940 
  def __eq__(self, other):
11941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11942 
 
11943 
  def __ne__(self, other):
11944 
    return not (self == other)
11945 
 
3064 chandransh 11946 
class acceptOrder_args:
1113 chandransh 11947 
  """
11948 
  Attributes:
3064 chandransh 11949 
   - orderId
1113 chandransh 11950 
  """
11951 
 
11952 
  thrift_spec = (
11953 
    None, # 0
3064 chandransh 11954 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11955 
  )
11956 
 
3064 chandransh 11957 
  def __init__(self, orderId=None,):
11958 
    self.orderId = orderId
1113 chandransh 11959 
 
11960 
  def read(self, iprot):
11961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11963 
      return
11964 
    iprot.readStructBegin()
11965 
    while True:
11966 
      (fname, ftype, fid) = iprot.readFieldBegin()
11967 
      if ftype == TType.STOP:
11968 
        break
11969 
      if fid == 1:
11970 
        if ftype == TType.I64:
3064 chandransh 11971 
          self.orderId = iprot.readI64();
1113 chandransh 11972 
        else:
11973 
          iprot.skip(ftype)
11974 
      else:
11975 
        iprot.skip(ftype)
11976 
      iprot.readFieldEnd()
11977 
    iprot.readStructEnd()
11978 
 
11979 
  def write(self, oprot):
11980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11982 
      return
3064 chandransh 11983 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11984 
    if self.orderId is not None:
3064 chandransh 11985 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11986 
      oprot.writeI64(self.orderId)
1113 chandransh 11987 
      oprot.writeFieldEnd()
11988 
    oprot.writeFieldStop()
11989 
    oprot.writeStructEnd()
11990 
 
3431 rajveer 11991 
  def validate(self):
11992 
    return
11993 
 
11994 
 
1113 chandransh 11995 
  def __repr__(self):
11996 
    L = ['%s=%r' % (key, value)
11997 
      for key, value in self.__dict__.iteritems()]
11998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11999 
 
12000 
  def __eq__(self, other):
12001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12002 
 
12003 
  def __ne__(self, other):
12004 
    return not (self == other)
12005 
 
3064 chandransh 12006 
class acceptOrder_result:
1113 chandransh 12007 
  """
12008 
  Attributes:
12009 
   - success
12010 
   - ex
12011 
  """
12012 
 
12013 
  thrift_spec = (
3064 chandransh 12014 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12015 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12016 
  )
12017 
 
12018 
  def __init__(self, success=None, ex=None,):
12019 
    self.success = success
12020 
    self.ex = ex
12021 
 
12022 
  def read(self, iprot):
12023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12025 
      return
12026 
    iprot.readStructBegin()
12027 
    while True:
12028 
      (fname, ftype, fid) = iprot.readFieldBegin()
12029 
      if ftype == TType.STOP:
12030 
        break
12031 
      if fid == 0:
3064 chandransh 12032 
        if ftype == TType.BOOL:
12033 
          self.success = iprot.readBool();
1113 chandransh 12034 
        else:
12035 
          iprot.skip(ftype)
12036 
      elif fid == 1:
12037 
        if ftype == TType.STRUCT:
12038 
          self.ex = TransactionServiceException()
12039 
          self.ex.read(iprot)
12040 
        else:
12041 
          iprot.skip(ftype)
12042 
      else:
12043 
        iprot.skip(ftype)
12044 
      iprot.readFieldEnd()
12045 
    iprot.readStructEnd()
12046 
 
12047 
  def write(self, oprot):
12048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12050 
      return
3064 chandransh 12051 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12052 
    if self.success is not None:
3064 chandransh 12053 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12054 
      oprot.writeBool(self.success)
1113 chandransh 12055 
      oprot.writeFieldEnd()
3431 rajveer 12056 
    if self.ex is not None:
1113 chandransh 12057 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12058 
      self.ex.write(oprot)
12059 
      oprot.writeFieldEnd()
12060 
    oprot.writeFieldStop()
12061 
    oprot.writeStructEnd()
12062 
 
3431 rajveer 12063 
  def validate(self):
12064 
    return
12065 
 
12066 
 
1113 chandransh 12067 
  def __repr__(self):
12068 
    L = ['%s=%r' % (key, value)
12069 
      for key, value in self.__dict__.iteritems()]
12070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12071 
 
12072 
  def __eq__(self, other):
12073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12074 
 
12075 
  def __ne__(self, other):
12076 
    return not (self == other)
12077 
 
3064 chandransh 12078 
class addBillingDetails_args:
1135 chandransh 12079 
  """
12080 
  Attributes:
3064 chandransh 12081 
   - orderId
12082 
   - invoice_number
4658 mandeep.dh 12083 
   - serialNumber
4283 anupam.sin 12084 
   - itemNumber
3064 chandransh 12085 
   - billed_by
4264 rajveer 12086 
   - jacketNumber
4283 anupam.sin 12087 
   - billingType
5110 mandeep.dh 12088 
   - fulfilmentWarehouseId
4763 rajveer 12089 
   - authorize
1135 chandransh 12090 
  """
12091 
 
12092 
  thrift_spec = (
12093 
    None, # 0
3064 chandransh 12094 
    (1, TType.I64, 'orderId', None, None, ), # 1
12095 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12096 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12097 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12098 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12099 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12100 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12101 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12102 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12103 
  )
12104 
 
5110 mandeep.dh 12105 
  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 12106 
    self.orderId = orderId
12107 
    self.invoice_number = invoice_number
4658 mandeep.dh 12108 
    self.serialNumber = serialNumber
4283 anupam.sin 12109 
    self.itemNumber = itemNumber
3064 chandransh 12110 
    self.billed_by = billed_by
4264 rajveer 12111 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12112 
    self.billingType = billingType
5110 mandeep.dh 12113 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12114 
    self.authorize = authorize
1135 chandransh 12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 1:
12126 
        if ftype == TType.I64:
3064 chandransh 12127 
          self.orderId = iprot.readI64();
1135 chandransh 12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      elif fid == 2:
3064 chandransh 12131 
        if ftype == TType.STRING:
12132 
          self.invoice_number = iprot.readString();
1135 chandransh 12133 
        else:
12134 
          iprot.skip(ftype)
3064 chandransh 12135 
      elif fid == 3:
5411 rajveer 12136 
        if ftype == TType.LIST:
12137 
          self.serialNumber = []
12138 
          (_etype227, _size224) = iprot.readListBegin()
12139 
          for _i228 in xrange(_size224):
12140 
            _elem229 = iprot.readString();
12141 
            self.serialNumber.append(_elem229)
12142 
          iprot.readListEnd()
3064 chandransh 12143 
        else:
12144 
          iprot.skip(ftype)
12145 
      elif fid == 4:
5411 rajveer 12146 
        if ftype == TType.LIST:
12147 
          self.itemNumber = []
12148 
          (_etype233, _size230) = iprot.readListBegin()
12149 
          for _i234 in xrange(_size230):
12150 
            _elem235 = iprot.readString();
12151 
            self.itemNumber.append(_elem235)
12152 
          iprot.readListEnd()
3064 chandransh 12153 
        else:
12154 
          iprot.skip(ftype)
12155 
      elif fid == 5:
12156 
        if ftype == TType.STRING:
4283 anupam.sin 12157 
          self.billed_by = iprot.readString();
3064 chandransh 12158 
        else:
12159 
          iprot.skip(ftype)
12160 
      elif fid == 6:
12161 
        if ftype == TType.I64:
4283 anupam.sin 12162 
          self.jacketNumber = iprot.readI64();
12163 
        else:
12164 
          iprot.skip(ftype)
12165 
      elif fid == 7:
12166 
        if ftype == TType.I64:
3064 chandransh 12167 
          self.billingType = iprot.readI64();
12168 
        else:
12169 
          iprot.skip(ftype)
4283 anupam.sin 12170 
      elif fid == 8:
12171 
        if ftype == TType.I64:
5110 mandeep.dh 12172 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12173 
        else:
12174 
          iprot.skip(ftype)
4763 rajveer 12175 
      elif fid == 9:
12176 
        if ftype == TType.BOOL:
12177 
          self.authorize = iprot.readBool();
12178 
        else:
12179 
          iprot.skip(ftype)
1246 chandransh 12180 
      else:
12181 
        iprot.skip(ftype)
12182 
      iprot.readFieldEnd()
12183 
    iprot.readStructEnd()
12184 
 
12185 
  def write(self, oprot):
12186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12188 
      return
4283 anupam.sin 12189 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12190 
    if self.orderId is not None:
3064 chandransh 12191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12192 
      oprot.writeI64(self.orderId)
1246 chandransh 12193 
      oprot.writeFieldEnd()
4283 anupam.sin 12194 
    if self.invoice_number is not None:
12195 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12196 
      oprot.writeString(self.invoice_number)
1246 chandransh 12197 
      oprot.writeFieldEnd()
4658 mandeep.dh 12198 
    if self.serialNumber is not None:
5411 rajveer 12199 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12200 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12201 
      for iter236 in self.serialNumber:
12202 
        oprot.writeString(iter236)
12203 
      oprot.writeListEnd()
3064 chandransh 12204 
      oprot.writeFieldEnd()
3431 rajveer 12205 
    if self.itemNumber is not None:
5411 rajveer 12206 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12207 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12208 
      for iter237 in self.itemNumber:
12209 
        oprot.writeString(iter237)
12210 
      oprot.writeListEnd()
3064 chandransh 12211 
      oprot.writeFieldEnd()
4283 anupam.sin 12212 
    if self.billed_by is not None:
12213 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12214 
      oprot.writeString(self.billed_by)
3064 chandransh 12215 
      oprot.writeFieldEnd()
4283 anupam.sin 12216 
    if self.jacketNumber is not None:
12217 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12218 
      oprot.writeI64(self.jacketNumber)
12219 
      oprot.writeFieldEnd()
3431 rajveer 12220 
    if self.billingType is not None:
4283 anupam.sin 12221 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12222 
      oprot.writeI64(self.billingType)
12223 
      oprot.writeFieldEnd()
5110 mandeep.dh 12224 
    if self.fulfilmentWarehouseId is not None:
12225 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12226 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12227 
      oprot.writeFieldEnd()
4763 rajveer 12228 
    if self.authorize is not None:
12229 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12230 
      oprot.writeBool(self.authorize)
12231 
      oprot.writeFieldEnd()
1246 chandransh 12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
3431 rajveer 12235 
  def validate(self):
12236 
    return
12237 
 
12238 
 
1246 chandransh 12239 
  def __repr__(self):
12240 
    L = ['%s=%r' % (key, value)
12241 
      for key, value in self.__dict__.iteritems()]
12242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12243 
 
12244 
  def __eq__(self, other):
12245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12246 
 
12247 
  def __ne__(self, other):
12248 
    return not (self == other)
12249 
 
4283 anupam.sin 12250 
class addBillingDetails_result:
1246 chandransh 12251 
  """
12252 
  Attributes:
3064 chandransh 12253 
   - success
1246 chandransh 12254 
   - ex
12255 
  """
12256 
 
12257 
  thrift_spec = (
3064 chandransh 12258 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12260 
  )
12261 
 
3064 chandransh 12262 
  def __init__(self, success=None, ex=None,):
12263 
    self.success = success
1246 chandransh 12264 
    self.ex = ex
12265 
 
12266 
  def read(self, iprot):
12267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12269 
      return
12270 
    iprot.readStructBegin()
12271 
    while True:
12272 
      (fname, ftype, fid) = iprot.readFieldBegin()
12273 
      if ftype == TType.STOP:
12274 
        break
3064 chandransh 12275 
      if fid == 0:
12276 
        if ftype == TType.BOOL:
12277 
          self.success = iprot.readBool();
12278 
        else:
12279 
          iprot.skip(ftype)
12280 
      elif fid == 1:
1246 chandransh 12281 
        if ftype == TType.STRUCT:
12282 
          self.ex = TransactionServiceException()
12283 
          self.ex.read(iprot)
12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      else:
12287 
        iprot.skip(ftype)
12288 
      iprot.readFieldEnd()
12289 
    iprot.readStructEnd()
12290 
 
12291 
  def write(self, oprot):
12292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12294 
      return
4283 anupam.sin 12295 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12296 
    if self.success is not None:
3064 chandransh 12297 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12298 
      oprot.writeBool(self.success)
12299 
      oprot.writeFieldEnd()
3431 rajveer 12300 
    if self.ex is not None:
1246 chandransh 12301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12302 
      self.ex.write(oprot)
12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
3431 rajveer 12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
1246 chandransh 12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
4579 rajveer 12322 
class addInvoiceNumber_args:
12323 
  """
12324 
  Attributes:
12325 
   - orderId
12326 
   - invoiceNumber
4763 rajveer 12327 
   - color
4579 rajveer 12328 
  """
12329 
 
12330 
  thrift_spec = (
12331 
    None, # 0
12332 
    (1, TType.I64, 'orderId', None, None, ), # 1
12333 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12334 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12335 
  )
12336 
 
4763 rajveer 12337 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12338 
    self.orderId = orderId
12339 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12340 
    self.color = color
4579 rajveer 12341 
 
12342 
  def read(self, iprot):
12343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12345 
      return
12346 
    iprot.readStructBegin()
12347 
    while True:
12348 
      (fname, ftype, fid) = iprot.readFieldBegin()
12349 
      if ftype == TType.STOP:
12350 
        break
12351 
      if fid == 1:
12352 
        if ftype == TType.I64:
12353 
          self.orderId = iprot.readI64();
12354 
        else:
12355 
          iprot.skip(ftype)
12356 
      elif fid == 2:
12357 
        if ftype == TType.STRING:
12358 
          self.invoiceNumber = iprot.readString();
12359 
        else:
12360 
          iprot.skip(ftype)
4763 rajveer 12361 
      elif fid == 3:
12362 
        if ftype == TType.STRING:
12363 
          self.color = iprot.readString();
12364 
        else:
12365 
          iprot.skip(ftype)
4579 rajveer 12366 
      else:
12367 
        iprot.skip(ftype)
12368 
      iprot.readFieldEnd()
12369 
    iprot.readStructEnd()
12370 
 
12371 
  def write(self, oprot):
12372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12374 
      return
12375 
    oprot.writeStructBegin('addInvoiceNumber_args')
12376 
    if self.orderId is not None:
12377 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12378 
      oprot.writeI64(self.orderId)
12379 
      oprot.writeFieldEnd()
12380 
    if self.invoiceNumber is not None:
12381 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12382 
      oprot.writeString(self.invoiceNumber)
12383 
      oprot.writeFieldEnd()
4763 rajveer 12384 
    if self.color is not None:
12385 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12386 
      oprot.writeString(self.color)
12387 
      oprot.writeFieldEnd()
4579 rajveer 12388 
    oprot.writeFieldStop()
12389 
    oprot.writeStructEnd()
12390 
 
12391 
  def validate(self):
12392 
    return
12393 
 
12394 
 
12395 
  def __repr__(self):
12396 
    L = ['%s=%r' % (key, value)
12397 
      for key, value in self.__dict__.iteritems()]
12398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12399 
 
12400 
  def __eq__(self, other):
12401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12402 
 
12403 
  def __ne__(self, other):
12404 
    return not (self == other)
12405 
 
12406 
class addInvoiceNumber_result:
12407 
  """
12408 
  Attributes:
12409 
   - ex
12410 
  """
12411 
 
12412 
  thrift_spec = (
12413 
    None, # 0
12414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12415 
  )
12416 
 
12417 
  def __init__(self, ex=None,):
12418 
    self.ex = ex
12419 
 
12420 
  def read(self, iprot):
12421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12423 
      return
12424 
    iprot.readStructBegin()
12425 
    while True:
12426 
      (fname, ftype, fid) = iprot.readFieldBegin()
12427 
      if ftype == TType.STOP:
12428 
        break
12429 
      if fid == 1:
12430 
        if ftype == TType.STRUCT:
12431 
          self.ex = TransactionServiceException()
12432 
          self.ex.read(iprot)
12433 
        else:
12434 
          iprot.skip(ftype)
12435 
      else:
12436 
        iprot.skip(ftype)
12437 
      iprot.readFieldEnd()
12438 
    iprot.readStructEnd()
12439 
 
12440 
  def write(self, oprot):
12441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12443 
      return
12444 
    oprot.writeStructBegin('addInvoiceNumber_result')
12445 
    if self.ex is not None:
12446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12447 
      self.ex.write(oprot)
12448 
      oprot.writeFieldEnd()
12449 
    oprot.writeFieldStop()
12450 
    oprot.writeStructEnd()
12451 
 
12452 
  def validate(self):
12453 
    return
12454 
 
12455 
 
12456 
  def __repr__(self):
12457 
    L = ['%s=%r' % (key, value)
12458 
      for key, value in self.__dict__.iteritems()]
12459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12460 
 
12461 
  def __eq__(self, other):
12462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12463 
 
12464 
  def __ne__(self, other):
12465 
    return not (self == other)
12466 
 
4910 phani.kuma 12467 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12468 
  """
12469 
  Attributes:
3064 chandransh 12470 
   - warehouseId
1408 ankur.sing 12471 
   - providerId
3064 chandransh 12472 
   - cod
4910 phani.kuma 12473 
   - orderIds
1408 ankur.sing 12474 
  """
12475 
 
12476 
  thrift_spec = (
12477 
    None, # 0
3064 chandransh 12478 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12479 
    (2, TType.I64, 'providerId', None, None, ), # 2
12480 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12481 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12482 
  )
12483 
 
4910 phani.kuma 12484 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12485 
    self.warehouseId = warehouseId
1408 ankur.sing 12486 
    self.providerId = providerId
3064 chandransh 12487 
    self.cod = cod
4910 phani.kuma 12488 
    self.orderIds = orderIds
1408 ankur.sing 12489 
 
12490 
  def read(self, iprot):
12491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12493 
      return
12494 
    iprot.readStructBegin()
12495 
    while True:
12496 
      (fname, ftype, fid) = iprot.readFieldBegin()
12497 
      if ftype == TType.STOP:
12498 
        break
12499 
      if fid == 1:
12500 
        if ftype == TType.I64:
3064 chandransh 12501 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12502 
        else:
12503 
          iprot.skip(ftype)
12504 
      elif fid == 2:
12505 
        if ftype == TType.I64:
3064 chandransh 12506 
          self.providerId = iprot.readI64();
1408 ankur.sing 12507 
        else:
12508 
          iprot.skip(ftype)
3064 chandransh 12509 
      elif fid == 3:
12510 
        if ftype == TType.BOOL:
12511 
          self.cod = iprot.readBool();
12512 
        else:
12513 
          iprot.skip(ftype)
4910 phani.kuma 12514 
      elif fid == 4:
12515 
        if ftype == TType.LIST:
12516 
          self.orderIds = []
5411 rajveer 12517 
          (_etype241, _size238) = iprot.readListBegin()
12518 
          for _i242 in xrange(_size238):
12519 
            _elem243 = iprot.readI64();
12520 
            self.orderIds.append(_elem243)
4910 phani.kuma 12521 
          iprot.readListEnd()
12522 
        else:
12523 
          iprot.skip(ftype)
1408 ankur.sing 12524 
      else:
12525 
        iprot.skip(ftype)
12526 
      iprot.readFieldEnd()
12527 
    iprot.readStructEnd()
12528 
 
12529 
  def write(self, oprot):
12530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12532 
      return
4910 phani.kuma 12533 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12534 
    if self.warehouseId is not None:
3064 chandransh 12535 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12536 
      oprot.writeI64(self.warehouseId)
12537 
      oprot.writeFieldEnd()
3431 rajveer 12538 
    if self.providerId is not None:
3064 chandransh 12539 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12540 
      oprot.writeI64(self.providerId)
12541 
      oprot.writeFieldEnd()
3431 rajveer 12542 
    if self.cod is not None:
3064 chandransh 12543 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12544 
      oprot.writeBool(self.cod)
1408 ankur.sing 12545 
      oprot.writeFieldEnd()
4910 phani.kuma 12546 
    if self.orderIds is not None:
12547 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12548 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12549 
      for iter244 in self.orderIds:
12550 
        oprot.writeI64(iter244)
4910 phani.kuma 12551 
      oprot.writeListEnd()
12552 
      oprot.writeFieldEnd()
1408 ankur.sing 12553 
    oprot.writeFieldStop()
12554 
    oprot.writeStructEnd()
12555 
 
3431 rajveer 12556 
  def validate(self):
12557 
    return
12558 
 
12559 
 
1408 ankur.sing 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 
 
4910 phani.kuma 12571 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12572 
  """
12573 
  Attributes:
12574 
   - success
3064 chandransh 12575 
   - ex
1408 ankur.sing 12576 
  """
12577 
 
12578 
  thrift_spec = (
3064 chandransh 12579 
    (0, TType.BOOL, 'success', None, None, ), # 0
12580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12581 
  )
12582 
 
3064 chandransh 12583 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12584 
    self.success = success
3064 chandransh 12585 
    self.ex = ex
1408 ankur.sing 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();
1408 ankur.sing 12599 
        else:
12600 
          iprot.skip(ftype)
3064 chandransh 12601 
      elif fid == 1:
12602 
        if ftype == TType.STRUCT:
12603 
          self.ex = TransactionServiceException()
12604 
          self.ex.read(iprot)
12605 
        else:
12606 
          iprot.skip(ftype)
1408 ankur.sing 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
4910 phani.kuma 12616 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12617 
    if self.success is not None:
3064 chandransh 12618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12619 
      oprot.writeBool(self.success)
1408 ankur.sing 12620 
      oprot.writeFieldEnd()
3431 rajveer 12621 
    if self.ex is not None:
3064 chandransh 12622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12623 
      self.ex.write(oprot)
12624 
      oprot.writeFieldEnd()
1408 ankur.sing 12625 
    oprot.writeFieldStop()
12626 
    oprot.writeStructEnd()
12627 
 
3431 rajveer 12628 
  def validate(self):
12629 
    return
12630 
 
12631 
 
1408 ankur.sing 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 
 
4910 phani.kuma 12643 
class markOrdersAsPickedUp_args:
4410 rajveer 12644 
  """
12645 
  Attributes:
12646 
   - providerId
4910 phani.kuma 12647 
   - pickupDetails
4410 rajveer 12648 
  """
12649 
 
12650 
  thrift_spec = (
12651 
    None, # 0
4910 phani.kuma 12652 
    (1, TType.I64, 'providerId', None, None, ), # 1
12653 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12654 
  )
12655 
 
4910 phani.kuma 12656 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12657 
    self.providerId = providerId
4910 phani.kuma 12658 
    self.pickupDetails = pickupDetails
4410 rajveer 12659 
 
12660 
  def read(self, iprot):
12661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12663 
      return
12664 
    iprot.readStructBegin()
12665 
    while True:
12666 
      (fname, ftype, fid) = iprot.readFieldBegin()
12667 
      if ftype == TType.STOP:
12668 
        break
12669 
      if fid == 1:
12670 
        if ftype == TType.I64:
4910 phani.kuma 12671 
          self.providerId = iprot.readI64();
4410 rajveer 12672 
        else:
12673 
          iprot.skip(ftype)
12674 
      elif fid == 2:
4910 phani.kuma 12675 
        if ftype == TType.MAP:
12676 
          self.pickupDetails = {}
5411 rajveer 12677 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12678 
          for _i249 in xrange(_size245):
12679 
            _key250 = iprot.readString();
12680 
            _val251 = iprot.readString();
12681 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12682 
          iprot.readMapEnd()
4410 rajveer 12683 
        else:
12684 
          iprot.skip(ftype)
12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
4910 phani.kuma 12694 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12695 
    if self.providerId is not None:
4910 phani.kuma 12696 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12697 
      oprot.writeI64(self.providerId)
12698 
      oprot.writeFieldEnd()
4910 phani.kuma 12699 
    if self.pickupDetails is not None:
12700 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12701 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12702 
      for kiter252,viter253 in self.pickupDetails.items():
12703 
        oprot.writeString(kiter252)
12704 
        oprot.writeString(viter253)
4910 phani.kuma 12705 
      oprot.writeMapEnd()
4410 rajveer 12706 
      oprot.writeFieldEnd()
12707 
    oprot.writeFieldStop()
12708 
    oprot.writeStructEnd()
12709 
 
12710 
  def validate(self):
12711 
    return
12712 
 
12713 
 
12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
4910 phani.kuma 12725 
class markOrdersAsPickedUp_result:
4410 rajveer 12726 
  """
12727 
  Attributes:
12728 
   - ex
12729 
  """
12730 
 
12731 
  thrift_spec = (
4910 phani.kuma 12732 
    None, # 0
4410 rajveer 12733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12734 
  )
12735 
 
4910 phani.kuma 12736 
  def __init__(self, ex=None,):
4410 rajveer 12737 
    self.ex = ex
12738 
 
12739 
  def read(self, iprot):
12740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12742 
      return
12743 
    iprot.readStructBegin()
12744 
    while True:
12745 
      (fname, ftype, fid) = iprot.readFieldBegin()
12746 
      if ftype == TType.STOP:
12747 
        break
4910 phani.kuma 12748 
      if fid == 1:
4410 rajveer 12749 
        if ftype == TType.STRUCT:
12750 
          self.ex = TransactionServiceException()
12751 
          self.ex.read(iprot)
12752 
        else:
12753 
          iprot.skip(ftype)
12754 
      else:
12755 
        iprot.skip(ftype)
12756 
      iprot.readFieldEnd()
12757 
    iprot.readStructEnd()
12758 
 
12759 
  def write(self, oprot):
12760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12762 
      return
4910 phani.kuma 12763 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12764 
    if self.ex is not None:
12765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12766 
      self.ex.write(oprot)
12767 
      oprot.writeFieldEnd()
12768 
    oprot.writeFieldStop()
12769 
    oprot.writeStructEnd()
12770 
 
12771 
  def validate(self):
12772 
    return
12773 
 
12774 
 
12775 
  def __repr__(self):
12776 
    L = ['%s=%r' % (key, value)
12777 
      for key, value in self.__dict__.iteritems()]
12778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12779 
 
12780 
  def __eq__(self, other):
12781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12782 
 
12783 
  def __ne__(self, other):
12784 
    return not (self == other)
12785 
 
4910 phani.kuma 12786 
class getOrdersNotPickedUp_args:
304 ashish 12787 
  """
12788 
  Attributes:
3064 chandransh 12789 
   - providerId
304 ashish 12790 
  """
94 ashish 12791 
 
304 ashish 12792 
  thrift_spec = (
12793 
    None, # 0
3064 chandransh 12794 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12795 
  )
12796 
 
4910 phani.kuma 12797 
  def __init__(self, providerId=None,):
3064 chandransh 12798 
    self.providerId = providerId
304 ashish 12799 
 
12800 
  def read(self, iprot):
12801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12803 
      return
12804 
    iprot.readStructBegin()
12805 
    while True:
12806 
      (fname, ftype, fid) = iprot.readFieldBegin()
12807 
      if ftype == TType.STOP:
12808 
        break
12809 
      if fid == 1:
12810 
        if ftype == TType.I64:
3064 chandransh 12811 
          self.providerId = iprot.readI64();
304 ashish 12812 
        else:
12813 
          iprot.skip(ftype)
12814 
      else:
12815 
        iprot.skip(ftype)
12816 
      iprot.readFieldEnd()
12817 
    iprot.readStructEnd()
12818 
 
12819 
  def write(self, oprot):
12820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12822 
      return
4910 phani.kuma 12823 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12824 
    if self.providerId is not None:
3064 chandransh 12825 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12826 
      oprot.writeI64(self.providerId)
304 ashish 12827 
      oprot.writeFieldEnd()
12828 
    oprot.writeFieldStop()
12829 
    oprot.writeStructEnd()
12830 
 
3431 rajveer 12831 
  def validate(self):
12832 
    return
12833 
 
12834 
 
304 ashish 12835 
  def __repr__(self):
12836 
    L = ['%s=%r' % (key, value)
12837 
      for key, value in self.__dict__.iteritems()]
12838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12839 
 
12840 
  def __eq__(self, other):
12841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12842 
 
12843 
  def __ne__(self, other):
12844 
    return not (self == other)
12845 
 
4910 phani.kuma 12846 
class getOrdersNotPickedUp_result:
304 ashish 12847 
  """
12848 
  Attributes:
12849 
   - success
12850 
  """
12851 
 
12852 
  thrift_spec = (
3064 chandransh 12853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12854 
  )
12855 
 
4910 phani.kuma 12856 
  def __init__(self, success=None,):
304 ashish 12857 
    self.success = success
12858 
 
12859 
  def read(self, iprot):
12860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12862 
      return
12863 
    iprot.readStructBegin()
12864 
    while True:
12865 
      (fname, ftype, fid) = iprot.readFieldBegin()
12866 
      if ftype == TType.STOP:
12867 
        break
12868 
      if fid == 0:
12869 
        if ftype == TType.LIST:
12870 
          self.success = []
5411 rajveer 12871 
          (_etype257, _size254) = iprot.readListBegin()
12872 
          for _i258 in xrange(_size254):
12873 
            _elem259 = Order()
12874 
            _elem259.read(iprot)
12875 
            self.success.append(_elem259)
304 ashish 12876 
          iprot.readListEnd()
12877 
        else:
12878 
          iprot.skip(ftype)
12879 
      else:
12880 
        iprot.skip(ftype)
12881 
      iprot.readFieldEnd()
12882 
    iprot.readStructEnd()
12883 
 
12884 
  def write(self, oprot):
12885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12887 
      return
4910 phani.kuma 12888 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12889 
    if self.success is not None:
304 ashish 12890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12892 
      for iter260 in self.success:
12893 
        iter260.write(oprot)
304 ashish 12894 
      oprot.writeListEnd()
12895 
      oprot.writeFieldEnd()
12896 
    oprot.writeFieldStop()
12897 
    oprot.writeStructEnd()
12898 
 
3431 rajveer 12899 
  def validate(self):
12900 
    return
12901 
 
12902 
 
304 ashish 12903 
  def __repr__(self):
12904 
    L = ['%s=%r' % (key, value)
12905 
      for key, value in self.__dict__.iteritems()]
12906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12907 
 
12908 
  def __eq__(self, other):
12909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12910 
 
12911 
  def __ne__(self, other):
12912 
    return not (self == other)
12913 
 
3064 chandransh 12914 
class markOrdersAsDelivered_args:
304 ashish 12915 
  """
12916 
  Attributes:
3064 chandransh 12917 
   - providerId
12918 
   - deliveredOrders
304 ashish 12919 
  """
12920 
 
12921 
  thrift_spec = (
12922 
    None, # 0
3064 chandransh 12923 
    (1, TType.I64, 'providerId', None, None, ), # 1
12924 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12925 
  )
12926 
 
3064 chandransh 12927 
  def __init__(self, providerId=None, deliveredOrders=None,):
12928 
    self.providerId = providerId
12929 
    self.deliveredOrders = deliveredOrders
304 ashish 12930 
 
12931 
  def read(self, iprot):
12932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12934 
      return
12935 
    iprot.readStructBegin()
12936 
    while True:
12937 
      (fname, ftype, fid) = iprot.readFieldBegin()
12938 
      if ftype == TType.STOP:
12939 
        break
12940 
      if fid == 1:
12941 
        if ftype == TType.I64:
3064 chandransh 12942 
          self.providerId = iprot.readI64();
304 ashish 12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      elif fid == 2:
3064 chandransh 12946 
        if ftype == TType.MAP:
12947 
          self.deliveredOrders = {}
5411 rajveer 12948 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
12949 
          for _i265 in xrange(_size261):
12950 
            _key266 = iprot.readString();
12951 
            _val267 = iprot.readString();
12952 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 12953 
          iprot.readMapEnd()
304 ashish 12954 
        else:
12955 
          iprot.skip(ftype)
12956 
      else:
12957 
        iprot.skip(ftype)
12958 
      iprot.readFieldEnd()
12959 
    iprot.readStructEnd()
12960 
 
12961 
  def write(self, oprot):
12962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12964 
      return
3064 chandransh 12965 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12966 
    if self.providerId is not None:
3064 chandransh 12967 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12968 
      oprot.writeI64(self.providerId)
304 ashish 12969 
      oprot.writeFieldEnd()
3431 rajveer 12970 
    if self.deliveredOrders is not None:
3064 chandransh 12971 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12972 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 12973 
      for kiter268,viter269 in self.deliveredOrders.items():
12974 
        oprot.writeString(kiter268)
12975 
        oprot.writeString(viter269)
3064 chandransh 12976 
      oprot.writeMapEnd()
304 ashish 12977 
      oprot.writeFieldEnd()
12978 
    oprot.writeFieldStop()
12979 
    oprot.writeStructEnd()
12980 
 
3431 rajveer 12981 
  def validate(self):
12982 
    return
12983 
 
12984 
 
304 ashish 12985 
  def __repr__(self):
12986 
    L = ['%s=%r' % (key, value)
12987 
      for key, value in self.__dict__.iteritems()]
12988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12989 
 
12990 
  def __eq__(self, other):
12991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12992 
 
12993 
  def __ne__(self, other):
12994 
    return not (self == other)
12995 
 
3064 chandransh 12996 
class markOrdersAsDelivered_result:
12997 
  """
12998 
  Attributes:
12999 
   - ex
13000 
  """
304 ashish 13001 
 
13002 
  thrift_spec = (
3064 chandransh 13003 
    None, # 0
13004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13005 
  )
13006 
 
3064 chandransh 13007 
  def __init__(self, ex=None,):
13008 
    self.ex = ex
304 ashish 13009 
 
1596 ankur.sing 13010 
  def read(self, iprot):
13011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13013 
      return
13014 
    iprot.readStructBegin()
13015 
    while True:
13016 
      (fname, ftype, fid) = iprot.readFieldBegin()
13017 
      if ftype == TType.STOP:
13018 
        break
3064 chandransh 13019 
      if fid == 1:
13020 
        if ftype == TType.STRUCT:
13021 
          self.ex = TransactionServiceException()
13022 
          self.ex.read(iprot)
13023 
        else:
13024 
          iprot.skip(ftype)
1596 ankur.sing 13025 
      else:
13026 
        iprot.skip(ftype)
13027 
      iprot.readFieldEnd()
13028 
    iprot.readStructEnd()
13029 
 
13030 
  def write(self, oprot):
13031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13033 
      return
3064 chandransh 13034 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13035 
    if self.ex is not None:
3064 chandransh 13036 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13037 
      self.ex.write(oprot)
13038 
      oprot.writeFieldEnd()
1596 ankur.sing 13039 
    oprot.writeFieldStop()
13040 
    oprot.writeStructEnd()
13041 
 
3431 rajveer 13042 
  def validate(self):
13043 
    return
13044 
 
13045 
 
1596 ankur.sing 13046 
  def __repr__(self):
13047 
    L = ['%s=%r' % (key, value)
13048 
      for key, value in self.__dict__.iteritems()]
13049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13050 
 
13051 
  def __eq__(self, other):
13052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13053 
 
13054 
  def __ne__(self, other):
13055 
    return not (self == other)
13056 
 
4910 phani.kuma 13057 
class markAsRTOrders_args:
1596 ankur.sing 13058 
  """
13059 
  Attributes:
3064 chandransh 13060 
   - providerId
13061 
   - returnedOrders
1596 ankur.sing 13062 
  """
13063 
 
13064 
  thrift_spec = (
3064 chandransh 13065 
    None, # 0
13066 
    (1, TType.I64, 'providerId', None, None, ), # 1
13067 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13068 
  )
13069 
 
3064 chandransh 13070 
  def __init__(self, providerId=None, returnedOrders=None,):
13071 
    self.providerId = providerId
13072 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13073 
 
13074 
  def read(self, iprot):
13075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13077 
      return
13078 
    iprot.readStructBegin()
13079 
    while True:
13080 
      (fname, ftype, fid) = iprot.readFieldBegin()
13081 
      if ftype == TType.STOP:
13082 
        break
3064 chandransh 13083 
      if fid == 1:
1596 ankur.sing 13084 
        if ftype == TType.I64:
3064 chandransh 13085 
          self.providerId = iprot.readI64();
1596 ankur.sing 13086 
        else:
13087 
          iprot.skip(ftype)
3064 chandransh 13088 
      elif fid == 2:
13089 
        if ftype == TType.MAP:
13090 
          self.returnedOrders = {}
5411 rajveer 13091 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
13092 
          for _i274 in xrange(_size270):
13093 
            _key275 = iprot.readString();
13094 
            _val276 = iprot.readString();
13095 
            self.returnedOrders[_key275] = _val276
3064 chandransh 13096 
          iprot.readMapEnd()
13097 
        else:
13098 
          iprot.skip(ftype)
1596 ankur.sing 13099 
      else:
13100 
        iprot.skip(ftype)
13101 
      iprot.readFieldEnd()
13102 
    iprot.readStructEnd()
13103 
 
13104 
  def write(self, oprot):
13105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13107 
      return
4910 phani.kuma 13108 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13109 
    if self.providerId is not None:
3064 chandransh 13110 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13111 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13112 
      oprot.writeFieldEnd()
3431 rajveer 13113 
    if self.returnedOrders is not None:
3064 chandransh 13114 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13115 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 13116 
      for kiter277,viter278 in self.returnedOrders.items():
13117 
        oprot.writeString(kiter277)
13118 
        oprot.writeString(viter278)
3064 chandransh 13119 
      oprot.writeMapEnd()
13120 
      oprot.writeFieldEnd()
1596 ankur.sing 13121 
    oprot.writeFieldStop()
13122 
    oprot.writeStructEnd()
13123 
 
3431 rajveer 13124 
  def validate(self):
13125 
    return
13126 
 
13127 
 
1596 ankur.sing 13128 
  def __repr__(self):
13129 
    L = ['%s=%r' % (key, value)
13130 
      for key, value in self.__dict__.iteritems()]
13131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13132 
 
13133 
  def __eq__(self, other):
13134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13135 
 
13136 
  def __ne__(self, other):
13137 
    return not (self == other)
13138 
 
4910 phani.kuma 13139 
class markAsRTOrders_result:
3064 chandransh 13140 
  """
13141 
  Attributes:
13142 
   - ex
13143 
  """
1596 ankur.sing 13144 
 
1627 ankur.sing 13145 
  thrift_spec = (
3064 chandransh 13146 
    None, # 0
13147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13148 
  )
13149 
 
3064 chandransh 13150 
  def __init__(self, ex=None,):
13151 
    self.ex = ex
13152 
 
1627 ankur.sing 13153 
  def read(self, iprot):
13154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13156 
      return
13157 
    iprot.readStructBegin()
13158 
    while True:
13159 
      (fname, ftype, fid) = iprot.readFieldBegin()
13160 
      if ftype == TType.STOP:
13161 
        break
3064 chandransh 13162 
      if fid == 1:
13163 
        if ftype == TType.STRUCT:
13164 
          self.ex = TransactionServiceException()
13165 
          self.ex.read(iprot)
13166 
        else:
13167 
          iprot.skip(ftype)
1627 ankur.sing 13168 
      else:
13169 
        iprot.skip(ftype)
13170 
      iprot.readFieldEnd()
13171 
    iprot.readStructEnd()
13172 
 
13173 
  def write(self, oprot):
13174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13176 
      return
4910 phani.kuma 13177 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13178 
    if self.ex is not None:
3064 chandransh 13179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13180 
      self.ex.write(oprot)
13181 
      oprot.writeFieldEnd()
1627 ankur.sing 13182 
    oprot.writeFieldStop()
13183 
    oprot.writeStructEnd()
13184 
 
3431 rajveer 13185 
  def validate(self):
13186 
    return
13187 
 
13188 
 
1627 ankur.sing 13189 
  def __repr__(self):
13190 
    L = ['%s=%r' % (key, value)
13191 
      for key, value in self.__dict__.iteritems()]
13192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13193 
 
13194 
  def __eq__(self, other):
13195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13196 
 
13197 
  def __ne__(self, other):
13198 
    return not (self == other)
13199 
 
4910 phani.kuma 13200 
class getRTOrders_args:
13201 
  """
13202 
  Attributes:
13203 
   - providerId
13204 
  """
13205 
 
13206 
  thrift_spec = (
13207 
    None, # 0
13208 
    (1, TType.I64, 'providerId', None, None, ), # 1
13209 
  )
13210 
 
13211 
  def __init__(self, providerId=None,):
13212 
    self.providerId = providerId
13213 
 
13214 
  def read(self, iprot):
13215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13217 
      return
13218 
    iprot.readStructBegin()
13219 
    while True:
13220 
      (fname, ftype, fid) = iprot.readFieldBegin()
13221 
      if ftype == TType.STOP:
13222 
        break
13223 
      if fid == 1:
13224 
        if ftype == TType.I64:
13225 
          self.providerId = iprot.readI64();
13226 
        else:
13227 
          iprot.skip(ftype)
13228 
      else:
13229 
        iprot.skip(ftype)
13230 
      iprot.readFieldEnd()
13231 
    iprot.readStructEnd()
13232 
 
13233 
  def write(self, oprot):
13234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13236 
      return
13237 
    oprot.writeStructBegin('getRTOrders_args')
13238 
    if self.providerId is not None:
13239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13240 
      oprot.writeI64(self.providerId)
13241 
      oprot.writeFieldEnd()
13242 
    oprot.writeFieldStop()
13243 
    oprot.writeStructEnd()
13244 
 
13245 
  def validate(self):
13246 
    return
13247 
 
13248 
 
13249 
  def __repr__(self):
13250 
    L = ['%s=%r' % (key, value)
13251 
      for key, value in self.__dict__.iteritems()]
13252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13253 
 
13254 
  def __eq__(self, other):
13255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13256 
 
13257 
  def __ne__(self, other):
13258 
    return not (self == other)
13259 
 
13260 
class getRTOrders_result:
13261 
  """
13262 
  Attributes:
13263 
   - success
13264 
  """
13265 
 
13266 
  thrift_spec = (
13267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13268 
  )
13269 
 
13270 
  def __init__(self, success=None,):
13271 
    self.success = success
13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 0:
13283 
        if ftype == TType.LIST:
13284 
          self.success = []
5411 rajveer 13285 
          (_etype282, _size279) = iprot.readListBegin()
13286 
          for _i283 in xrange(_size279):
13287 
            _elem284 = Order()
13288 
            _elem284.read(iprot)
13289 
            self.success.append(_elem284)
4910 phani.kuma 13290 
          iprot.readListEnd()
13291 
        else:
13292 
          iprot.skip(ftype)
13293 
      else:
13294 
        iprot.skip(ftype)
13295 
      iprot.readFieldEnd()
13296 
    iprot.readStructEnd()
13297 
 
13298 
  def write(self, oprot):
13299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13301 
      return
13302 
    oprot.writeStructBegin('getRTOrders_result')
13303 
    if self.success is not None:
13304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13306 
      for iter285 in self.success:
13307 
        iter285.write(oprot)
4910 phani.kuma 13308 
      oprot.writeListEnd()
13309 
      oprot.writeFieldEnd()
13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
3064 chandransh 13328 
class updateNonDeliveryReason_args:
1627 ankur.sing 13329 
  """
13330 
  Attributes:
3064 chandransh 13331 
   - providerId
13332 
   - undeliveredOrders
1627 ankur.sing 13333 
  """
13334 
 
13335 
  thrift_spec = (
3064 chandransh 13336 
    None, # 0
13337 
    (1, TType.I64, 'providerId', None, None, ), # 1
13338 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13339 
  )
13340 
 
3064 chandransh 13341 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13342 
    self.providerId = providerId
13343 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13344 
 
13345 
  def read(self, iprot):
13346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13348 
      return
13349 
    iprot.readStructBegin()
13350 
    while True:
13351 
      (fname, ftype, fid) = iprot.readFieldBegin()
13352 
      if ftype == TType.STOP:
13353 
        break
3064 chandransh 13354 
      if fid == 1:
1627 ankur.sing 13355 
        if ftype == TType.I64:
3064 chandransh 13356 
          self.providerId = iprot.readI64();
1627 ankur.sing 13357 
        else:
13358 
          iprot.skip(ftype)
3064 chandransh 13359 
      elif fid == 2:
13360 
        if ftype == TType.MAP:
13361 
          self.undeliveredOrders = {}
5411 rajveer 13362 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
13363 
          for _i290 in xrange(_size286):
13364 
            _key291 = iprot.readString();
13365 
            _val292 = iprot.readString();
13366 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 13367 
          iprot.readMapEnd()
13368 
        else:
13369 
          iprot.skip(ftype)
1627 ankur.sing 13370 
      else:
13371 
        iprot.skip(ftype)
13372 
      iprot.readFieldEnd()
13373 
    iprot.readStructEnd()
13374 
 
13375 
  def write(self, oprot):
13376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13378 
      return
3064 chandransh 13379 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13380 
    if self.providerId is not None:
3064 chandransh 13381 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13382 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13383 
      oprot.writeFieldEnd()
3431 rajveer 13384 
    if self.undeliveredOrders is not None:
3064 chandransh 13385 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13386 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 13387 
      for kiter293,viter294 in self.undeliveredOrders.items():
13388 
        oprot.writeString(kiter293)
13389 
        oprot.writeString(viter294)
3064 chandransh 13390 
      oprot.writeMapEnd()
13391 
      oprot.writeFieldEnd()
1627 ankur.sing 13392 
    oprot.writeFieldStop()
13393 
    oprot.writeStructEnd()
13394 
 
3431 rajveer 13395 
  def validate(self):
13396 
    return
13397 
 
13398 
 
1627 ankur.sing 13399 
  def __repr__(self):
13400 
    L = ['%s=%r' % (key, value)
13401 
      for key, value in self.__dict__.iteritems()]
13402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13403 
 
13404 
  def __eq__(self, other):
13405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13406 
 
13407 
  def __ne__(self, other):
13408 
    return not (self == other)
13409 
 
3064 chandransh 13410 
class updateNonDeliveryReason_result:
1627 ankur.sing 13411 
  """
13412 
  Attributes:
3064 chandransh 13413 
   - ex
1627 ankur.sing 13414 
  """
13415 
 
13416 
  thrift_spec = (
4910 phani.kuma 13417 
    None, # 0
3064 chandransh 13418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13419 
  )
13420 
 
4910 phani.kuma 13421 
  def __init__(self, ex=None,):
3064 chandransh 13422 
    self.ex = ex
1627 ankur.sing 13423 
 
13424 
  def read(self, iprot):
13425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13427 
      return
13428 
    iprot.readStructBegin()
13429 
    while True:
13430 
      (fname, ftype, fid) = iprot.readFieldBegin()
13431 
      if ftype == TType.STOP:
13432 
        break
4910 phani.kuma 13433 
      if fid == 1:
13434 
        if ftype == TType.STRUCT:
13435 
          self.ex = TransactionServiceException()
13436 
          self.ex.read(iprot)
13437 
        else:
13438 
          iprot.skip(ftype)
13439 
      else:
13440 
        iprot.skip(ftype)
13441 
      iprot.readFieldEnd()
13442 
    iprot.readStructEnd()
13443 
 
13444 
  def write(self, oprot):
13445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13447 
      return
13448 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13449 
    if self.ex is not None:
13450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13451 
      self.ex.write(oprot)
13452 
      oprot.writeFieldEnd()
13453 
    oprot.writeFieldStop()
13454 
    oprot.writeStructEnd()
13455 
 
13456 
  def validate(self):
13457 
    return
13458 
 
13459 
 
13460 
  def __repr__(self):
13461 
    L = ['%s=%r' % (key, value)
13462 
      for key, value in self.__dict__.iteritems()]
13463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13464 
 
13465 
  def __eq__(self, other):
13466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13467 
 
13468 
  def __ne__(self, other):
13469 
    return not (self == other)
13470 
 
13471 
class getNonDeliveredOrdersbyCourier_args:
13472 
  """
13473 
  Attributes:
13474 
   - providerId
13475 
  """
13476 
 
13477 
  thrift_spec = (
13478 
    None, # 0
13479 
    (1, TType.I64, 'providerId', None, None, ), # 1
13480 
  )
13481 
 
13482 
  def __init__(self, providerId=None,):
13483 
    self.providerId = providerId
13484 
 
13485 
  def read(self, iprot):
13486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13488 
      return
13489 
    iprot.readStructBegin()
13490 
    while True:
13491 
      (fname, ftype, fid) = iprot.readFieldBegin()
13492 
      if ftype == TType.STOP:
13493 
        break
13494 
      if fid == 1:
13495 
        if ftype == TType.I64:
13496 
          self.providerId = iprot.readI64();
13497 
        else:
13498 
          iprot.skip(ftype)
13499 
      else:
13500 
        iprot.skip(ftype)
13501 
      iprot.readFieldEnd()
13502 
    iprot.readStructEnd()
13503 
 
13504 
  def write(self, oprot):
13505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13507 
      return
13508 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13509 
    if self.providerId is not None:
13510 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13511 
      oprot.writeI64(self.providerId)
13512 
      oprot.writeFieldEnd()
13513 
    oprot.writeFieldStop()
13514 
    oprot.writeStructEnd()
13515 
 
13516 
  def validate(self):
13517 
    return
13518 
 
13519 
 
13520 
  def __repr__(self):
13521 
    L = ['%s=%r' % (key, value)
13522 
      for key, value in self.__dict__.iteritems()]
13523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13524 
 
13525 
  def __eq__(self, other):
13526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13527 
 
13528 
  def __ne__(self, other):
13529 
    return not (self == other)
13530 
 
13531 
class getNonDeliveredOrdersbyCourier_result:
13532 
  """
13533 
  Attributes:
13534 
   - success
13535 
  """
13536 
 
13537 
  thrift_spec = (
13538 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13539 
  )
13540 
 
13541 
  def __init__(self, success=None,):
13542 
    self.success = success
13543 
 
13544 
  def read(self, iprot):
13545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13547 
      return
13548 
    iprot.readStructBegin()
13549 
    while True:
13550 
      (fname, ftype, fid) = iprot.readFieldBegin()
13551 
      if ftype == TType.STOP:
13552 
        break
4581 phani.kuma 13553 
      if fid == 0:
13554 
        if ftype == TType.LIST:
13555 
          self.success = []
5411 rajveer 13556 
          (_etype298, _size295) = iprot.readListBegin()
13557 
          for _i299 in xrange(_size295):
13558 
            _elem300 = Order()
13559 
            _elem300.read(iprot)
13560 
            self.success.append(_elem300)
4581 phani.kuma 13561 
          iprot.readListEnd()
13562 
        else:
13563 
          iprot.skip(ftype)
4910 phani.kuma 13564 
      else:
13565 
        iprot.skip(ftype)
13566 
      iprot.readFieldEnd()
13567 
    iprot.readStructEnd()
13568 
 
13569 
  def write(self, oprot):
13570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13572 
      return
13573 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13574 
    if self.success is not None:
13575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13576 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13577 
      for iter301 in self.success:
13578 
        iter301.write(oprot)
4910 phani.kuma 13579 
      oprot.writeListEnd()
13580 
      oprot.writeFieldEnd()
13581 
    oprot.writeFieldStop()
13582 
    oprot.writeStructEnd()
13583 
 
13584 
  def validate(self):
13585 
    return
13586 
 
13587 
 
13588 
  def __repr__(self):
13589 
    L = ['%s=%r' % (key, value)
13590 
      for key, value in self.__dict__.iteritems()]
13591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13592 
 
13593 
  def __eq__(self, other):
13594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13595 
 
13596 
  def __ne__(self, other):
13597 
    return not (self == other)
13598 
 
13599 
class markOrdersAsLocalConnected_args:
13600 
  """
13601 
  Attributes:
13602 
   - providerId
13603 
   - local_connected_orders
13604 
  """
13605 
 
13606 
  thrift_spec = (
13607 
    None, # 0
13608 
    (1, TType.I64, 'providerId', None, None, ), # 1
13609 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13610 
  )
13611 
 
13612 
  def __init__(self, providerId=None, local_connected_orders=None,):
13613 
    self.providerId = providerId
13614 
    self.local_connected_orders = local_connected_orders
13615 
 
13616 
  def read(self, iprot):
13617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13619 
      return
13620 
    iprot.readStructBegin()
13621 
    while True:
13622 
      (fname, ftype, fid) = iprot.readFieldBegin()
13623 
      if ftype == TType.STOP:
13624 
        break
13625 
      if fid == 1:
13626 
        if ftype == TType.I64:
13627 
          self.providerId = iprot.readI64();
13628 
        else:
13629 
          iprot.skip(ftype)
13630 
      elif fid == 2:
13631 
        if ftype == TType.MAP:
13632 
          self.local_connected_orders = {}
5411 rajveer 13633 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13634 
          for _i306 in xrange(_size302):
13635 
            _key307 = iprot.readString();
13636 
            _val308 = iprot.readString();
13637 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13638 
          iprot.readMapEnd()
13639 
        else:
13640 
          iprot.skip(ftype)
13641 
      else:
13642 
        iprot.skip(ftype)
13643 
      iprot.readFieldEnd()
13644 
    iprot.readStructEnd()
13645 
 
13646 
  def write(self, oprot):
13647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13649 
      return
13650 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13651 
    if self.providerId is not None:
13652 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13653 
      oprot.writeI64(self.providerId)
13654 
      oprot.writeFieldEnd()
13655 
    if self.local_connected_orders is not None:
13656 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13657 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13658 
      for kiter309,viter310 in self.local_connected_orders.items():
13659 
        oprot.writeString(kiter309)
13660 
        oprot.writeString(viter310)
4910 phani.kuma 13661 
      oprot.writeMapEnd()
13662 
      oprot.writeFieldEnd()
13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
13681 
class markOrdersAsLocalConnected_result:
13682 
  """
13683 
  Attributes:
13684 
   - ex
13685 
  """
13686 
 
13687 
  thrift_spec = (
13688 
    None, # 0
13689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13690 
  )
13691 
 
13692 
  def __init__(self, ex=None,):
13693 
    self.ex = ex
13694 
 
13695 
  def read(self, iprot):
13696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13698 
      return
13699 
    iprot.readStructBegin()
13700 
    while True:
13701 
      (fname, ftype, fid) = iprot.readFieldBegin()
13702 
      if ftype == TType.STOP:
13703 
        break
13704 
      if fid == 1:
3064 chandransh 13705 
        if ftype == TType.STRUCT:
13706 
          self.ex = TransactionServiceException()
13707 
          self.ex.read(iprot)
1627 ankur.sing 13708 
        else:
13709 
          iprot.skip(ftype)
13710 
      else:
13711 
        iprot.skip(ftype)
13712 
      iprot.readFieldEnd()
13713 
    iprot.readStructEnd()
13714 
 
13715 
  def write(self, oprot):
13716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13718 
      return
4910 phani.kuma 13719 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13720 
    if self.ex is not None:
13721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13722 
      self.ex.write(oprot)
13723 
      oprot.writeFieldEnd()
13724 
    oprot.writeFieldStop()
13725 
    oprot.writeStructEnd()
13726 
 
13727 
  def validate(self):
13728 
    return
13729 
 
13730 
 
13731 
  def __repr__(self):
13732 
    L = ['%s=%r' % (key, value)
13733 
      for key, value in self.__dict__.iteritems()]
13734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13735 
 
13736 
  def __eq__(self, other):
13737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13738 
 
13739 
  def __ne__(self, other):
13740 
    return not (self == other)
13741 
 
13742 
class getOrdersNotLocalConnected_args:
13743 
  """
13744 
  Attributes:
13745 
   - providerId
13746 
  """
13747 
 
13748 
  thrift_spec = (
13749 
    None, # 0
13750 
    (1, TType.I64, 'providerId', None, None, ), # 1
13751 
  )
13752 
 
13753 
  def __init__(self, providerId=None,):
13754 
    self.providerId = providerId
13755 
 
13756 
  def read(self, iprot):
13757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13759 
      return
13760 
    iprot.readStructBegin()
13761 
    while True:
13762 
      (fname, ftype, fid) = iprot.readFieldBegin()
13763 
      if ftype == TType.STOP:
13764 
        break
13765 
      if fid == 1:
13766 
        if ftype == TType.I64:
13767 
          self.providerId = iprot.readI64();
13768 
        else:
13769 
          iprot.skip(ftype)
13770 
      else:
13771 
        iprot.skip(ftype)
13772 
      iprot.readFieldEnd()
13773 
    iprot.readStructEnd()
13774 
 
13775 
  def write(self, oprot):
13776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13778 
      return
13779 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13780 
    if self.providerId is not None:
13781 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13782 
      oprot.writeI64(self.providerId)
13783 
      oprot.writeFieldEnd()
13784 
    oprot.writeFieldStop()
13785 
    oprot.writeStructEnd()
13786 
 
13787 
  def validate(self):
13788 
    return
13789 
 
13790 
 
13791 
  def __repr__(self):
13792 
    L = ['%s=%r' % (key, value)
13793 
      for key, value in self.__dict__.iteritems()]
13794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13795 
 
13796 
  def __eq__(self, other):
13797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13798 
 
13799 
  def __ne__(self, other):
13800 
    return not (self == other)
13801 
 
13802 
class getOrdersNotLocalConnected_result:
13803 
  """
13804 
  Attributes:
13805 
   - success
13806 
  """
13807 
 
13808 
  thrift_spec = (
13809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13810 
  )
13811 
 
13812 
  def __init__(self, success=None,):
13813 
    self.success = success
13814 
 
13815 
  def read(self, iprot):
13816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13818 
      return
13819 
    iprot.readStructBegin()
13820 
    while True:
13821 
      (fname, ftype, fid) = iprot.readFieldBegin()
13822 
      if ftype == TType.STOP:
13823 
        break
13824 
      if fid == 0:
13825 
        if ftype == TType.LIST:
13826 
          self.success = []
5411 rajveer 13827 
          (_etype314, _size311) = iprot.readListBegin()
13828 
          for _i315 in xrange(_size311):
13829 
            _elem316 = Order()
13830 
            _elem316.read(iprot)
13831 
            self.success.append(_elem316)
4910 phani.kuma 13832 
          iprot.readListEnd()
13833 
        else:
13834 
          iprot.skip(ftype)
13835 
      else:
13836 
        iprot.skip(ftype)
13837 
      iprot.readFieldEnd()
13838 
    iprot.readStructEnd()
13839 
 
13840 
  def write(self, oprot):
13841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13843 
      return
13844 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13845 
    if self.success is not None:
13846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13848 
      for iter317 in self.success:
13849 
        iter317.write(oprot)
4581 phani.kuma 13850 
      oprot.writeListEnd()
13851 
      oprot.writeFieldEnd()
4910 phani.kuma 13852 
    oprot.writeFieldStop()
13853 
    oprot.writeStructEnd()
13854 
 
13855 
  def validate(self):
13856 
    return
13857 
 
13858 
 
13859 
  def __repr__(self):
13860 
    L = ['%s=%r' % (key, value)
13861 
      for key, value in self.__dict__.iteritems()]
13862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13863 
 
13864 
  def __eq__(self, other):
13865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13866 
 
13867 
  def __ne__(self, other):
13868 
    return not (self == other)
13869 
 
13870 
class markOrdersAsDestinationCityReached_args:
13871 
  """
13872 
  Attributes:
13873 
   - providerId
13874 
   - destination_city_reached_orders
13875 
  """
13876 
 
13877 
  thrift_spec = (
13878 
    None, # 0
13879 
    (1, TType.I64, 'providerId', None, None, ), # 1
13880 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13881 
  )
13882 
 
13883 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13884 
    self.providerId = providerId
13885 
    self.destination_city_reached_orders = destination_city_reached_orders
13886 
 
13887 
  def read(self, iprot):
13888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13890 
      return
13891 
    iprot.readStructBegin()
13892 
    while True:
13893 
      (fname, ftype, fid) = iprot.readFieldBegin()
13894 
      if ftype == TType.STOP:
13895 
        break
13896 
      if fid == 1:
13897 
        if ftype == TType.I64:
13898 
          self.providerId = iprot.readI64();
13899 
        else:
13900 
          iprot.skip(ftype)
13901 
      elif fid == 2:
13902 
        if ftype == TType.MAP:
13903 
          self.destination_city_reached_orders = {}
5411 rajveer 13904 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13905 
          for _i322 in xrange(_size318):
13906 
            _key323 = iprot.readString();
13907 
            _val324 = iprot.readString();
13908 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13909 
          iprot.readMapEnd()
13910 
        else:
13911 
          iprot.skip(ftype)
13912 
      else:
13913 
        iprot.skip(ftype)
13914 
      iprot.readFieldEnd()
13915 
    iprot.readStructEnd()
13916 
 
13917 
  def write(self, oprot):
13918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13920 
      return
13921 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13922 
    if self.providerId is not None:
13923 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13924 
      oprot.writeI64(self.providerId)
13925 
      oprot.writeFieldEnd()
13926 
    if self.destination_city_reached_orders is not None:
13927 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13928 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13929 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13930 
        oprot.writeString(kiter325)
13931 
        oprot.writeString(viter326)
4910 phani.kuma 13932 
      oprot.writeMapEnd()
13933 
      oprot.writeFieldEnd()
13934 
    oprot.writeFieldStop()
13935 
    oprot.writeStructEnd()
13936 
 
13937 
  def validate(self):
13938 
    return
13939 
 
13940 
 
13941 
  def __repr__(self):
13942 
    L = ['%s=%r' % (key, value)
13943 
      for key, value in self.__dict__.iteritems()]
13944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13945 
 
13946 
  def __eq__(self, other):
13947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13948 
 
13949 
  def __ne__(self, other):
13950 
    return not (self == other)
13951 
 
13952 
class markOrdersAsDestinationCityReached_result:
13953 
  """
13954 
  Attributes:
13955 
   - ex
13956 
  """
13957 
 
13958 
  thrift_spec = (
13959 
    None, # 0
13960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13961 
  )
13962 
 
13963 
  def __init__(self, ex=None,):
13964 
    self.ex = ex
13965 
 
13966 
  def read(self, iprot):
13967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13969 
      return
13970 
    iprot.readStructBegin()
13971 
    while True:
13972 
      (fname, ftype, fid) = iprot.readFieldBegin()
13973 
      if ftype == TType.STOP:
13974 
        break
13975 
      if fid == 1:
13976 
        if ftype == TType.STRUCT:
13977 
          self.ex = TransactionServiceException()
13978 
          self.ex.read(iprot)
13979 
        else:
13980 
          iprot.skip(ftype)
13981 
      else:
13982 
        iprot.skip(ftype)
13983 
      iprot.readFieldEnd()
13984 
    iprot.readStructEnd()
13985 
 
13986 
  def write(self, oprot):
13987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13989 
      return
13990 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13991 
    if self.ex is not None:
3064 chandransh 13992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13993 
      self.ex.write(oprot)
1627 ankur.sing 13994 
      oprot.writeFieldEnd()
13995 
    oprot.writeFieldStop()
13996 
    oprot.writeStructEnd()
13997 
 
3431 rajveer 13998 
  def validate(self):
13999 
    return
14000 
 
14001 
 
1627 ankur.sing 14002 
  def __repr__(self):
14003 
    L = ['%s=%r' % (key, value)
14004 
      for key, value in self.__dict__.iteritems()]
14005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14006 
 
14007 
  def __eq__(self, other):
14008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14009 
 
14010 
  def __ne__(self, other):
14011 
    return not (self == other)
14012 
 
4910 phani.kuma 14013 
class markOrdersAsFirstDeliveryAttempted_args:
14014 
  """
14015 
  Attributes:
14016 
   - providerId
14017 
   - first_atdl_orders
14018 
  """
14019 
 
14020 
  thrift_spec = (
14021 
    None, # 0
14022 
    (1, TType.I64, 'providerId', None, None, ), # 1
14023 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14024 
  )
14025 
 
14026 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14027 
    self.providerId = providerId
14028 
    self.first_atdl_orders = first_atdl_orders
14029 
 
14030 
  def read(self, iprot):
14031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14033 
      return
14034 
    iprot.readStructBegin()
14035 
    while True:
14036 
      (fname, ftype, fid) = iprot.readFieldBegin()
14037 
      if ftype == TType.STOP:
14038 
        break
14039 
      if fid == 1:
14040 
        if ftype == TType.I64:
14041 
          self.providerId = iprot.readI64();
14042 
        else:
14043 
          iprot.skip(ftype)
14044 
      elif fid == 2:
14045 
        if ftype == TType.MAP:
14046 
          self.first_atdl_orders = {}
5411 rajveer 14047 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14048 
          for _i331 in xrange(_size327):
14049 
            _key332 = iprot.readString();
14050 
            _val333 = iprot.readString();
14051 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 14052 
          iprot.readMapEnd()
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      else:
14056 
        iprot.skip(ftype)
14057 
      iprot.readFieldEnd()
14058 
    iprot.readStructEnd()
14059 
 
14060 
  def write(self, oprot):
14061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14063 
      return
14064 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14065 
    if self.providerId is not None:
14066 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14067 
      oprot.writeI64(self.providerId)
14068 
      oprot.writeFieldEnd()
14069 
    if self.first_atdl_orders is not None:
14070 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14071 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 14072 
      for kiter334,viter335 in self.first_atdl_orders.items():
14073 
        oprot.writeString(kiter334)
14074 
        oprot.writeString(viter335)
4910 phani.kuma 14075 
      oprot.writeMapEnd()
14076 
      oprot.writeFieldEnd()
14077 
    oprot.writeFieldStop()
14078 
    oprot.writeStructEnd()
14079 
 
14080 
  def validate(self):
14081 
    return
14082 
 
14083 
 
14084 
  def __repr__(self):
14085 
    L = ['%s=%r' % (key, value)
14086 
      for key, value in self.__dict__.iteritems()]
14087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14088 
 
14089 
  def __eq__(self, other):
14090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14091 
 
14092 
  def __ne__(self, other):
14093 
    return not (self == other)
14094 
 
14095 
class markOrdersAsFirstDeliveryAttempted_result:
14096 
  """
14097 
  Attributes:
14098 
   - ex
14099 
  """
14100 
 
14101 
  thrift_spec = (
14102 
    None, # 0
14103 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14104 
  )
14105 
 
14106 
  def __init__(self, ex=None,):
14107 
    self.ex = ex
14108 
 
14109 
  def read(self, iprot):
14110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14112 
      return
14113 
    iprot.readStructBegin()
14114 
    while True:
14115 
      (fname, ftype, fid) = iprot.readFieldBegin()
14116 
      if ftype == TType.STOP:
14117 
        break
14118 
      if fid == 1:
14119 
        if ftype == TType.STRUCT:
14120 
          self.ex = TransactionServiceException()
14121 
          self.ex.read(iprot)
14122 
        else:
14123 
          iprot.skip(ftype)
14124 
      else:
14125 
        iprot.skip(ftype)
14126 
      iprot.readFieldEnd()
14127 
    iprot.readStructEnd()
14128 
 
14129 
  def write(self, oprot):
14130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14132 
      return
14133 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14134 
    if self.ex is not None:
14135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14136 
      self.ex.write(oprot)
14137 
      oprot.writeFieldEnd()
14138 
    oprot.writeFieldStop()
14139 
    oprot.writeStructEnd()
14140 
 
14141 
  def validate(self):
14142 
    return
14143 
 
14144 
 
14145 
  def __repr__(self):
14146 
    L = ['%s=%r' % (key, value)
14147 
      for key, value in self.__dict__.iteritems()]
14148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14149 
 
14150 
  def __eq__(self, other):
14151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14152 
 
14153 
  def __ne__(self, other):
14154 
    return not (self == other)
14155 
 
3064 chandransh 14156 
class getUndeliveredOrders_args:
1886 ankur.sing 14157 
  """
14158 
  Attributes:
3064 chandransh 14159 
   - providerId
14160 
   - warehouseId
1886 ankur.sing 14161 
  """
1627 ankur.sing 14162 
 
1886 ankur.sing 14163 
  thrift_spec = (
14164 
    None, # 0
3064 chandransh 14165 
    (1, TType.I64, 'providerId', None, None, ), # 1
14166 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14167 
  )
14168 
 
3064 chandransh 14169 
  def __init__(self, providerId=None, warehouseId=None,):
14170 
    self.providerId = providerId
14171 
    self.warehouseId = warehouseId
1886 ankur.sing 14172 
 
14173 
  def read(self, iprot):
14174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14176 
      return
14177 
    iprot.readStructBegin()
14178 
    while True:
14179 
      (fname, ftype, fid) = iprot.readFieldBegin()
14180 
      if ftype == TType.STOP:
14181 
        break
14182 
      if fid == 1:
14183 
        if ftype == TType.I64:
3064 chandransh 14184 
          self.providerId = iprot.readI64();
1886 ankur.sing 14185 
        else:
14186 
          iprot.skip(ftype)
3064 chandransh 14187 
      elif fid == 2:
14188 
        if ftype == TType.I64:
14189 
          self.warehouseId = iprot.readI64();
14190 
        else:
14191 
          iprot.skip(ftype)
1886 ankur.sing 14192 
      else:
14193 
        iprot.skip(ftype)
14194 
      iprot.readFieldEnd()
14195 
    iprot.readStructEnd()
14196 
 
14197 
  def write(self, oprot):
14198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14200 
      return
3064 chandransh 14201 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14202 
    if self.providerId is not None:
3064 chandransh 14203 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14204 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14205 
      oprot.writeFieldEnd()
3431 rajveer 14206 
    if self.warehouseId is not None:
3064 chandransh 14207 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14208 
      oprot.writeI64(self.warehouseId)
14209 
      oprot.writeFieldEnd()
1886 ankur.sing 14210 
    oprot.writeFieldStop()
14211 
    oprot.writeStructEnd()
14212 
 
3431 rajveer 14213 
  def validate(self):
14214 
    return
14215 
 
14216 
 
1886 ankur.sing 14217 
  def __repr__(self):
14218 
    L = ['%s=%r' % (key, value)
14219 
      for key, value in self.__dict__.iteritems()]
14220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14221 
 
14222 
  def __eq__(self, other):
14223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14224 
 
14225 
  def __ne__(self, other):
14226 
    return not (self == other)
14227 
 
3064 chandransh 14228 
class getUndeliveredOrders_result:
1886 ankur.sing 14229 
  """
14230 
  Attributes:
14231 
   - success
14232 
  """
14233 
 
14234 
  thrift_spec = (
14235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14236 
  )
14237 
 
14238 
  def __init__(self, success=None,):
14239 
    self.success = success
14240 
 
14241 
  def read(self, iprot):
14242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14244 
      return
14245 
    iprot.readStructBegin()
14246 
    while True:
14247 
      (fname, ftype, fid) = iprot.readFieldBegin()
14248 
      if ftype == TType.STOP:
14249 
        break
14250 
      if fid == 0:
14251 
        if ftype == TType.LIST:
14252 
          self.success = []
5411 rajveer 14253 
          (_etype339, _size336) = iprot.readListBegin()
14254 
          for _i340 in xrange(_size336):
14255 
            _elem341 = Order()
14256 
            _elem341.read(iprot)
14257 
            self.success.append(_elem341)
1886 ankur.sing 14258 
          iprot.readListEnd()
14259 
        else:
14260 
          iprot.skip(ftype)
14261 
      else:
14262 
        iprot.skip(ftype)
14263 
      iprot.readFieldEnd()
14264 
    iprot.readStructEnd()
14265 
 
14266 
  def write(self, oprot):
14267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14269 
      return
3064 chandransh 14270 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14271 
    if self.success is not None:
1886 ankur.sing 14272 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14273 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14274 
      for iter342 in self.success:
14275 
        iter342.write(oprot)
1886 ankur.sing 14276 
      oprot.writeListEnd()
14277 
      oprot.writeFieldEnd()
14278 
    oprot.writeFieldStop()
14279 
    oprot.writeStructEnd()
14280 
 
3431 rajveer 14281 
  def validate(self):
14282 
    return
14283 
 
14284 
 
1886 ankur.sing 14285 
  def __repr__(self):
14286 
    L = ['%s=%r' % (key, value)
14287 
      for key, value in self.__dict__.iteritems()]
14288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14289 
 
14290 
  def __eq__(self, other):
14291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14292 
 
14293 
  def __ne__(self, other):
14294 
    return not (self == other)
14295 
 
4783 phani.kuma 14296 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14297 
 
14298 
  thrift_spec = (
14299 
  )
14300 
 
14301 
  def read(self, iprot):
14302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14304 
      return
14305 
    iprot.readStructBegin()
14306 
    while True:
14307 
      (fname, ftype, fid) = iprot.readFieldBegin()
14308 
      if ftype == TType.STOP:
14309 
        break
14310 
      else:
14311 
        iprot.skip(ftype)
14312 
      iprot.readFieldEnd()
14313 
    iprot.readStructEnd()
14314 
 
14315 
  def write(self, oprot):
14316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14318 
      return
14319 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14320 
    oprot.writeFieldStop()
14321 
    oprot.writeStructEnd()
14322 
 
14323 
  def validate(self):
14324 
    return
14325 
 
14326 
 
14327 
  def __repr__(self):
14328 
    L = ['%s=%r' % (key, value)
14329 
      for key, value in self.__dict__.iteritems()]
14330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14331 
 
14332 
  def __eq__(self, other):
14333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14334 
 
14335 
  def __ne__(self, other):
14336 
    return not (self == other)
14337 
 
14338 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14339 
  """
14340 
  Attributes:
14341 
   - success
14342 
  """
14343 
 
14344 
  thrift_spec = (
14345 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14346 
  )
14347 
 
14348 
  def __init__(self, success=None,):
14349 
    self.success = success
14350 
 
14351 
  def read(self, iprot):
14352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14354 
      return
14355 
    iprot.readStructBegin()
14356 
    while True:
14357 
      (fname, ftype, fid) = iprot.readFieldBegin()
14358 
      if ftype == TType.STOP:
14359 
        break
14360 
      if fid == 0:
14361 
        if ftype == TType.LIST:
14362 
          self.success = []
5411 rajveer 14363 
          (_etype346, _size343) = iprot.readListBegin()
14364 
          for _i347 in xrange(_size343):
14365 
            _elem348 = Order()
14366 
            _elem348.read(iprot)
14367 
            self.success.append(_elem348)
4783 phani.kuma 14368 
          iprot.readListEnd()
14369 
        else:
14370 
          iprot.skip(ftype)
14371 
      else:
14372 
        iprot.skip(ftype)
14373 
      iprot.readFieldEnd()
14374 
    iprot.readStructEnd()
14375 
 
14376 
  def write(self, oprot):
14377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14379 
      return
14380 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14381 
    if self.success is not None:
14382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14384 
      for iter349 in self.success:
14385 
        iter349.write(oprot)
4783 phani.kuma 14386 
      oprot.writeListEnd()
14387 
      oprot.writeFieldEnd()
14388 
    oprot.writeFieldStop()
14389 
    oprot.writeStructEnd()
14390 
 
14391 
  def validate(self):
14392 
    return
14393 
 
14394 
 
14395 
  def __repr__(self):
14396 
    L = ['%s=%r' % (key, value)
14397 
      for key, value in self.__dict__.iteritems()]
14398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14399 
 
14400 
  def __eq__(self, other):
14401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14402 
 
14403 
  def __ne__(self, other):
14404 
    return not (self == other)
14405 
 
2536 chandransh 14406 
class toggleDOAFlag_args:
14407 
  """
14408 
  Attributes:
14409 
   - orderId
14410 
  """
1886 ankur.sing 14411 
 
2536 chandransh 14412 
  thrift_spec = (
14413 
    None, # 0
14414 
    (1, TType.I64, 'orderId', None, None, ), # 1
14415 
  )
14416 
 
14417 
  def __init__(self, orderId=None,):
14418 
    self.orderId = orderId
14419 
 
14420 
  def read(self, iprot):
14421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14423 
      return
14424 
    iprot.readStructBegin()
14425 
    while True:
14426 
      (fname, ftype, fid) = iprot.readFieldBegin()
14427 
      if ftype == TType.STOP:
14428 
        break
14429 
      if fid == 1:
14430 
        if ftype == TType.I64:
14431 
          self.orderId = iprot.readI64();
14432 
        else:
14433 
          iprot.skip(ftype)
14434 
      else:
14435 
        iprot.skip(ftype)
14436 
      iprot.readFieldEnd()
14437 
    iprot.readStructEnd()
14438 
 
14439 
  def write(self, oprot):
14440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14442 
      return
14443 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14444 
    if self.orderId is not None:
2536 chandransh 14445 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14446 
      oprot.writeI64(self.orderId)
14447 
      oprot.writeFieldEnd()
14448 
    oprot.writeFieldStop()
14449 
    oprot.writeStructEnd()
14450 
 
3431 rajveer 14451 
  def validate(self):
14452 
    return
14453 
 
14454 
 
2536 chandransh 14455 
  def __repr__(self):
14456 
    L = ['%s=%r' % (key, value)
14457 
      for key, value in self.__dict__.iteritems()]
14458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14459 
 
14460 
  def __eq__(self, other):
14461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14462 
 
14463 
  def __ne__(self, other):
14464 
    return not (self == other)
14465 
 
14466 
class toggleDOAFlag_result:
14467 
  """
14468 
  Attributes:
14469 
   - success
14470 
   - ex
14471 
  """
14472 
 
14473 
  thrift_spec = (
14474 
    (0, TType.BOOL, 'success', None, None, ), # 0
14475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14476 
  )
14477 
 
14478 
  def __init__(self, success=None, ex=None,):
14479 
    self.success = success
14480 
    self.ex = ex
14481 
 
14482 
  def read(self, iprot):
14483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14485 
      return
14486 
    iprot.readStructBegin()
14487 
    while True:
14488 
      (fname, ftype, fid) = iprot.readFieldBegin()
14489 
      if ftype == TType.STOP:
14490 
        break
14491 
      if fid == 0:
14492 
        if ftype == TType.BOOL:
14493 
          self.success = iprot.readBool();
14494 
        else:
14495 
          iprot.skip(ftype)
14496 
      elif fid == 1:
14497 
        if ftype == TType.STRUCT:
14498 
          self.ex = TransactionServiceException()
14499 
          self.ex.read(iprot)
14500 
        else:
14501 
          iprot.skip(ftype)
14502 
      else:
14503 
        iprot.skip(ftype)
14504 
      iprot.readFieldEnd()
14505 
    iprot.readStructEnd()
14506 
 
14507 
  def write(self, oprot):
14508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14510 
      return
14511 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14512 
    if self.success is not None:
2536 chandransh 14513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14514 
      oprot.writeBool(self.success)
14515 
      oprot.writeFieldEnd()
3431 rajveer 14516 
    if self.ex is not None:
2536 chandransh 14517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14518 
      self.ex.write(oprot)
14519 
      oprot.writeFieldEnd()
14520 
    oprot.writeFieldStop()
14521 
    oprot.writeStructEnd()
14522 
 
3431 rajveer 14523 
  def validate(self):
14524 
    return
14525 
 
14526 
 
2536 chandransh 14527 
  def __repr__(self):
14528 
    L = ['%s=%r' % (key, value)
14529 
      for key, value in self.__dict__.iteritems()]
14530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14531 
 
14532 
  def __eq__(self, other):
14533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14534 
 
14535 
  def __ne__(self, other):
14536 
    return not (self == other)
14537 
 
4712 rajveer 14538 
class markOrderAsDelivered_args:
14539 
  """
14540 
  Attributes:
14541 
   - orderId
14542 
   - deliveryTimestamp
14543 
   - receiver
14544 
  """
14545 
 
14546 
  thrift_spec = None
14547 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14548 
    self.orderId = orderId
14549 
    self.deliveryTimestamp = deliveryTimestamp
14550 
    self.receiver = receiver
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 == 1:
14562 
        if ftype == TType.I64:
14563 
          self.orderId = iprot.readI64();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      elif fid == 2:
14567 
        if ftype == TType.I64:
14568 
          self.deliveryTimestamp = iprot.readI64();
14569 
        else:
14570 
          iprot.skip(ftype)
14571 
      elif fid == -1:
14572 
        if ftype == TType.STRING:
14573 
          self.receiver = iprot.readString();
14574 
        else:
14575 
          iprot.skip(ftype)
14576 
      else:
14577 
        iprot.skip(ftype)
14578 
      iprot.readFieldEnd()
14579 
    iprot.readStructEnd()
14580 
 
14581 
  def write(self, oprot):
14582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14584 
      return
14585 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14586 
    if self.receiver is not None:
14587 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14588 
      oprot.writeString(self.receiver)
14589 
      oprot.writeFieldEnd()
14590 
    if self.orderId is not None:
14591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14592 
      oprot.writeI64(self.orderId)
14593 
      oprot.writeFieldEnd()
14594 
    if self.deliveryTimestamp is not None:
14595 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14596 
      oprot.writeI64(self.deliveryTimestamp)
14597 
      oprot.writeFieldEnd()
14598 
    oprot.writeFieldStop()
14599 
    oprot.writeStructEnd()
14600 
 
14601 
  def validate(self):
14602 
    return
14603 
 
14604 
 
14605 
  def __repr__(self):
14606 
    L = ['%s=%r' % (key, value)
14607 
      for key, value in self.__dict__.iteritems()]
14608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14609 
 
14610 
  def __eq__(self, other):
14611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14612 
 
14613 
  def __ne__(self, other):
14614 
    return not (self == other)
14615 
 
14616 
class markOrderAsDelivered_result:
14617 
  """
14618 
  Attributes:
14619 
   - ex
14620 
  """
14621 
 
14622 
  thrift_spec = (
14623 
    None, # 0
14624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14625 
  )
14626 
 
14627 
  def __init__(self, ex=None,):
14628 
    self.ex = ex
14629 
 
14630 
  def read(self, iprot):
14631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14633 
      return
14634 
    iprot.readStructBegin()
14635 
    while True:
14636 
      (fname, ftype, fid) = iprot.readFieldBegin()
14637 
      if ftype == TType.STOP:
14638 
        break
14639 
      if fid == 1:
14640 
        if ftype == TType.STRUCT:
14641 
          self.ex = TransactionServiceException()
14642 
          self.ex.read(iprot)
14643 
        else:
14644 
          iprot.skip(ftype)
14645 
      else:
14646 
        iprot.skip(ftype)
14647 
      iprot.readFieldEnd()
14648 
    iprot.readStructEnd()
14649 
 
14650 
  def write(self, oprot):
14651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14653 
      return
14654 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14655 
    if self.ex is not None:
14656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14657 
      self.ex.write(oprot)
14658 
      oprot.writeFieldEnd()
14659 
    oprot.writeFieldStop()
14660 
    oprot.writeStructEnd()
14661 
 
14662 
  def validate(self):
14663 
    return
14664 
 
14665 
 
14666 
  def __repr__(self):
14667 
    L = ['%s=%r' % (key, value)
14668 
      for key, value in self.__dict__.iteritems()]
14669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14670 
 
14671 
  def __eq__(self, other):
14672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14673 
 
14674 
  def __ne__(self, other):
14675 
    return not (self == other)
14676 
 
5553 rajveer 14677 
class markOrderAsReceivedAtStore_args:
14678 
  """
14679 
  Attributes:
14680 
   - orderId
14681 
   - deliveryTimestamp
14682 
  """
14683 
 
14684 
  thrift_spec = (
14685 
    None, # 0
14686 
    (1, TType.I64, 'orderId', None, None, ), # 1
14687 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
14688 
  )
14689 
 
14690 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
14691 
    self.orderId = orderId
14692 
    self.deliveryTimestamp = deliveryTimestamp
14693 
 
14694 
  def read(self, iprot):
14695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14697 
      return
14698 
    iprot.readStructBegin()
14699 
    while True:
14700 
      (fname, ftype, fid) = iprot.readFieldBegin()
14701 
      if ftype == TType.STOP:
14702 
        break
14703 
      if fid == 1:
14704 
        if ftype == TType.I64:
14705 
          self.orderId = iprot.readI64();
14706 
        else:
14707 
          iprot.skip(ftype)
14708 
      elif fid == 2:
14709 
        if ftype == TType.I64:
14710 
          self.deliveryTimestamp = iprot.readI64();
14711 
        else:
14712 
          iprot.skip(ftype)
14713 
      else:
14714 
        iprot.skip(ftype)
14715 
      iprot.readFieldEnd()
14716 
    iprot.readStructEnd()
14717 
 
14718 
  def write(self, oprot):
14719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14721 
      return
14722 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
14723 
    if self.orderId is not None:
14724 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14725 
      oprot.writeI64(self.orderId)
14726 
      oprot.writeFieldEnd()
14727 
    if self.deliveryTimestamp is not None:
14728 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14729 
      oprot.writeI64(self.deliveryTimestamp)
14730 
      oprot.writeFieldEnd()
14731 
    oprot.writeFieldStop()
14732 
    oprot.writeStructEnd()
14733 
 
14734 
  def validate(self):
14735 
    return
14736 
 
14737 
 
14738 
  def __repr__(self):
14739 
    L = ['%s=%r' % (key, value)
14740 
      for key, value in self.__dict__.iteritems()]
14741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14742 
 
14743 
  def __eq__(self, other):
14744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14745 
 
14746 
  def __ne__(self, other):
14747 
    return not (self == other)
14748 
 
14749 
class markOrderAsReceivedAtStore_result:
14750 
  """
14751 
  Attributes:
14752 
   - ex
14753 
  """
14754 
 
14755 
  thrift_spec = (
14756 
    None, # 0
14757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14758 
  )
14759 
 
14760 
  def __init__(self, ex=None,):
14761 
    self.ex = ex
14762 
 
14763 
  def read(self, iprot):
14764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14766 
      return
14767 
    iprot.readStructBegin()
14768 
    while True:
14769 
      (fname, ftype, fid) = iprot.readFieldBegin()
14770 
      if ftype == TType.STOP:
14771 
        break
14772 
      if fid == 1:
14773 
        if ftype == TType.STRUCT:
14774 
          self.ex = TransactionServiceException()
14775 
          self.ex.read(iprot)
14776 
        else:
14777 
          iprot.skip(ftype)
14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
14788 
    if self.ex is not None:
14789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14790 
      self.ex.write(oprot)
14791 
      oprot.writeFieldEnd()
14792 
    oprot.writeFieldStop()
14793 
    oprot.writeStructEnd()
14794 
 
14795 
  def validate(self):
14796 
    return
14797 
 
14798 
 
14799 
  def __repr__(self):
14800 
    L = ['%s=%r' % (key, value)
14801 
      for key, value in self.__dict__.iteritems()]
14802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14803 
 
14804 
  def __eq__(self, other):
14805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14806 
 
14807 
  def __ne__(self, other):
14808 
    return not (self == other)
14809 
 
4454 rajveer 14810 
class markOrderDoaRequestReceived_args:
14811 
  """
14812 
  Attributes:
14813 
   - orderId
14814 
  """
14815 
 
14816 
  thrift_spec = (
14817 
    None, # 0
14818 
    (1, TType.I64, 'orderId', None, None, ), # 1
14819 
  )
14820 
 
14821 
  def __init__(self, orderId=None,):
14822 
    self.orderId = orderId
14823 
 
14824 
  def read(self, iprot):
14825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14827 
      return
14828 
    iprot.readStructBegin()
14829 
    while True:
14830 
      (fname, ftype, fid) = iprot.readFieldBegin()
14831 
      if ftype == TType.STOP:
14832 
        break
14833 
      if fid == 1:
14834 
        if ftype == TType.I64:
14835 
          self.orderId = iprot.readI64();
14836 
        else:
14837 
          iprot.skip(ftype)
14838 
      else:
14839 
        iprot.skip(ftype)
14840 
      iprot.readFieldEnd()
14841 
    iprot.readStructEnd()
14842 
 
14843 
  def write(self, oprot):
14844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14846 
      return
14847 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14848 
    if self.orderId is not None:
14849 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14850 
      oprot.writeI64(self.orderId)
14851 
      oprot.writeFieldEnd()
14852 
    oprot.writeFieldStop()
14853 
    oprot.writeStructEnd()
14854 
 
14855 
  def validate(self):
14856 
    return
14857 
 
14858 
 
14859 
  def __repr__(self):
14860 
    L = ['%s=%r' % (key, value)
14861 
      for key, value in self.__dict__.iteritems()]
14862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14863 
 
14864 
  def __eq__(self, other):
14865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14866 
 
14867 
  def __ne__(self, other):
14868 
    return not (self == other)
14869 
 
14870 
class markOrderDoaRequestReceived_result:
14871 
  """
14872 
  Attributes:
14873 
   - success
14874 
   - ex
14875 
  """
14876 
 
14877 
  thrift_spec = (
14878 
    (0, TType.BOOL, 'success', None, None, ), # 0
14879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14880 
  )
14881 
 
14882 
  def __init__(self, success=None, ex=None,):
14883 
    self.success = success
14884 
    self.ex = ex
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      if fid == 0:
14896 
        if ftype == TType.BOOL:
14897 
          self.success = iprot.readBool();
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      elif fid == 1:
14901 
        if ftype == TType.STRUCT:
14902 
          self.ex = TransactionServiceException()
14903 
          self.ex.read(iprot)
14904 
        else:
14905 
          iprot.skip(ftype)
14906 
      else:
14907 
        iprot.skip(ftype)
14908 
      iprot.readFieldEnd()
14909 
    iprot.readStructEnd()
14910 
 
14911 
  def write(self, oprot):
14912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14914 
      return
14915 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14916 
    if self.success is not None:
14917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14918 
      oprot.writeBool(self.success)
14919 
      oprot.writeFieldEnd()
14920 
    if self.ex is not None:
14921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14922 
      self.ex.write(oprot)
14923 
      oprot.writeFieldEnd()
14924 
    oprot.writeFieldStop()
14925 
    oprot.writeStructEnd()
14926 
 
14927 
  def validate(self):
14928 
    return
14929 
 
14930 
 
14931 
  def __repr__(self):
14932 
    L = ['%s=%r' % (key, value)
14933 
      for key, value in self.__dict__.iteritems()]
14934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14935 
 
14936 
  def __eq__(self, other):
14937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14938 
 
14939 
  def __ne__(self, other):
14940 
    return not (self == other)
14941 
 
14942 
class markOrderDoaRequestAuthorized_args:
14943 
  """
14944 
  Attributes:
14945 
   - orderId
14946 
   - isAuthorized
14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    None, # 0
14951 
    (1, TType.I64, 'orderId', None, None, ), # 1
14952 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14953 
  )
14954 
 
14955 
  def __init__(self, orderId=None, isAuthorized=None,):
14956 
    self.orderId = orderId
14957 
    self.isAuthorized = isAuthorized
14958 
 
14959 
  def read(self, iprot):
14960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14962 
      return
14963 
    iprot.readStructBegin()
14964 
    while True:
14965 
      (fname, ftype, fid) = iprot.readFieldBegin()
14966 
      if ftype == TType.STOP:
14967 
        break
14968 
      if fid == 1:
14969 
        if ftype == TType.I64:
14970 
          self.orderId = iprot.readI64();
14971 
        else:
14972 
          iprot.skip(ftype)
14973 
      elif fid == 2:
14974 
        if ftype == TType.BOOL:
14975 
          self.isAuthorized = iprot.readBool();
14976 
        else:
14977 
          iprot.skip(ftype)
14978 
      else:
14979 
        iprot.skip(ftype)
14980 
      iprot.readFieldEnd()
14981 
    iprot.readStructEnd()
14982 
 
14983 
  def write(self, oprot):
14984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14986 
      return
14987 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14988 
    if self.orderId is not None:
14989 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14990 
      oprot.writeI64(self.orderId)
14991 
      oprot.writeFieldEnd()
14992 
    if self.isAuthorized is not None:
14993 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14994 
      oprot.writeBool(self.isAuthorized)
14995 
      oprot.writeFieldEnd()
14996 
    oprot.writeFieldStop()
14997 
    oprot.writeStructEnd()
14998 
 
14999 
  def validate(self):
15000 
    return
15001 
 
15002 
 
15003 
  def __repr__(self):
15004 
    L = ['%s=%r' % (key, value)
15005 
      for key, value in self.__dict__.iteritems()]
15006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15007 
 
15008 
  def __eq__(self, other):
15009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15010 
 
15011 
  def __ne__(self, other):
15012 
    return not (self == other)
15013 
 
15014 
class markOrderDoaRequestAuthorized_result:
15015 
  """
15016 
  Attributes:
15017 
   - success
15018 
   - ex
15019 
  """
15020 
 
15021 
  thrift_spec = (
15022 
    (0, TType.BOOL, 'success', None, None, ), # 0
15023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15024 
  )
15025 
 
15026 
  def __init__(self, success=None, ex=None,):
15027 
    self.success = success
15028 
    self.ex = ex
15029 
 
15030 
  def read(self, iprot):
15031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15033 
      return
15034 
    iprot.readStructBegin()
15035 
    while True:
15036 
      (fname, ftype, fid) = iprot.readFieldBegin()
15037 
      if ftype == TType.STOP:
15038 
        break
15039 
      if fid == 0:
15040 
        if ftype == TType.BOOL:
15041 
          self.success = iprot.readBool();
15042 
        else:
15043 
          iprot.skip(ftype)
15044 
      elif fid == 1:
15045 
        if ftype == TType.STRUCT:
15046 
          self.ex = TransactionServiceException()
15047 
          self.ex.read(iprot)
15048 
        else:
15049 
          iprot.skip(ftype)
15050 
      else:
15051 
        iprot.skip(ftype)
15052 
      iprot.readFieldEnd()
15053 
    iprot.readStructEnd()
15054 
 
15055 
  def write(self, oprot):
15056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15058 
      return
15059 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15060 
    if self.success is not None:
15061 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15062 
      oprot.writeBool(self.success)
15063 
      oprot.writeFieldEnd()
15064 
    if self.ex is not None:
15065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15066 
      self.ex.write(oprot)
15067 
      oprot.writeFieldEnd()
15068 
    oprot.writeFieldStop()
15069 
    oprot.writeStructEnd()
15070 
 
15071 
  def validate(self):
15072 
    return
15073 
 
15074 
 
15075 
  def __repr__(self):
15076 
    L = ['%s=%r' % (key, value)
15077 
      for key, value in self.__dict__.iteritems()]
15078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15079 
 
15080 
  def __eq__(self, other):
15081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15082 
 
15083 
  def __ne__(self, other):
15084 
    return not (self == other)
15085 
 
4488 rajveer 15086 
class markOrderReturnRequestReceived_args:
15087 
  """
15088 
  Attributes:
15089 
   - orderId
15090 
  """
15091 
 
15092 
  thrift_spec = (
15093 
    None, # 0
15094 
    (1, TType.I64, 'orderId', None, None, ), # 1
15095 
  )
15096 
 
15097 
  def __init__(self, orderId=None,):
15098 
    self.orderId = orderId
15099 
 
15100 
  def read(self, iprot):
15101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15103 
      return
15104 
    iprot.readStructBegin()
15105 
    while True:
15106 
      (fname, ftype, fid) = iprot.readFieldBegin()
15107 
      if ftype == TType.STOP:
15108 
        break
15109 
      if fid == 1:
15110 
        if ftype == TType.I64:
15111 
          self.orderId = iprot.readI64();
15112 
        else:
15113 
          iprot.skip(ftype)
15114 
      else:
15115 
        iprot.skip(ftype)
15116 
      iprot.readFieldEnd()
15117 
    iprot.readStructEnd()
15118 
 
15119 
  def write(self, oprot):
15120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15122 
      return
15123 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15124 
    if self.orderId is not None:
15125 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15126 
      oprot.writeI64(self.orderId)
15127 
      oprot.writeFieldEnd()
15128 
    oprot.writeFieldStop()
15129 
    oprot.writeStructEnd()
15130 
 
15131 
  def validate(self):
15132 
    return
15133 
 
15134 
 
15135 
  def __repr__(self):
15136 
    L = ['%s=%r' % (key, value)
15137 
      for key, value in self.__dict__.iteritems()]
15138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15139 
 
15140 
  def __eq__(self, other):
15141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15142 
 
15143 
  def __ne__(self, other):
15144 
    return not (self == other)
15145 
 
15146 
class markOrderReturnRequestReceived_result:
15147 
  """
15148 
  Attributes:
15149 
   - success
15150 
   - ex
15151 
  """
15152 
 
15153 
  thrift_spec = (
15154 
    (0, TType.BOOL, 'success', None, None, ), # 0
15155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15156 
  )
15157 
 
15158 
  def __init__(self, success=None, ex=None,):
15159 
    self.success = success
15160 
    self.ex = ex
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 0:
15172 
        if ftype == TType.BOOL:
15173 
          self.success = iprot.readBool();
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      elif fid == 1:
15177 
        if ftype == TType.STRUCT:
15178 
          self.ex = TransactionServiceException()
15179 
          self.ex.read(iprot)
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      else:
15183 
        iprot.skip(ftype)
15184 
      iprot.readFieldEnd()
15185 
    iprot.readStructEnd()
15186 
 
15187 
  def write(self, oprot):
15188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15190 
      return
15191 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15192 
    if self.success is not None:
15193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15194 
      oprot.writeBool(self.success)
15195 
      oprot.writeFieldEnd()
15196 
    if self.ex is not None:
15197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15198 
      self.ex.write(oprot)
15199 
      oprot.writeFieldEnd()
15200 
    oprot.writeFieldStop()
15201 
    oprot.writeStructEnd()
15202 
 
15203 
  def validate(self):
15204 
    return
15205 
 
15206 
 
15207 
  def __repr__(self):
15208 
    L = ['%s=%r' % (key, value)
15209 
      for key, value in self.__dict__.iteritems()]
15210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15211 
 
15212 
  def __eq__(self, other):
15213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15214 
 
15215 
  def __ne__(self, other):
15216 
    return not (self == other)
15217 
 
15218 
class markOrderReturnRequestAuthorized_args:
15219 
  """
15220 
  Attributes:
15221 
   - orderId
15222 
   - isAuthorized
15223 
  """
15224 
 
15225 
  thrift_spec = (
15226 
    None, # 0
15227 
    (1, TType.I64, 'orderId', None, None, ), # 1
15228 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15229 
  )
15230 
 
15231 
  def __init__(self, orderId=None, isAuthorized=None,):
15232 
    self.orderId = orderId
15233 
    self.isAuthorized = isAuthorized
15234 
 
15235 
  def read(self, iprot):
15236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15238 
      return
15239 
    iprot.readStructBegin()
15240 
    while True:
15241 
      (fname, ftype, fid) = iprot.readFieldBegin()
15242 
      if ftype == TType.STOP:
15243 
        break
15244 
      if fid == 1:
15245 
        if ftype == TType.I64:
15246 
          self.orderId = iprot.readI64();
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      elif fid == 2:
15250 
        if ftype == TType.BOOL:
15251 
          self.isAuthorized = iprot.readBool();
15252 
        else:
15253 
          iprot.skip(ftype)
15254 
      else:
15255 
        iprot.skip(ftype)
15256 
      iprot.readFieldEnd()
15257 
    iprot.readStructEnd()
15258 
 
15259 
  def write(self, oprot):
15260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15262 
      return
15263 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15264 
    if self.orderId is not None:
15265 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15266 
      oprot.writeI64(self.orderId)
15267 
      oprot.writeFieldEnd()
15268 
    if self.isAuthorized is not None:
15269 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15270 
      oprot.writeBool(self.isAuthorized)
15271 
      oprot.writeFieldEnd()
15272 
    oprot.writeFieldStop()
15273 
    oprot.writeStructEnd()
15274 
 
15275 
  def validate(self):
15276 
    return
15277 
 
15278 
 
15279 
  def __repr__(self):
15280 
    L = ['%s=%r' % (key, value)
15281 
      for key, value in self.__dict__.iteritems()]
15282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15283 
 
15284 
  def __eq__(self, other):
15285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15286 
 
15287 
  def __ne__(self, other):
15288 
    return not (self == other)
15289 
 
15290 
class markOrderReturnRequestAuthorized_result:
15291 
  """
15292 
  Attributes:
15293 
   - success
15294 
   - ex
15295 
  """
15296 
 
15297 
  thrift_spec = (
15298 
    (0, TType.BOOL, 'success', None, None, ), # 0
15299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15300 
  )
15301 
 
15302 
  def __init__(self, success=None, ex=None,):
15303 
    self.success = success
15304 
    self.ex = ex
15305 
 
15306 
  def read(self, iprot):
15307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15309 
      return
15310 
    iprot.readStructBegin()
15311 
    while True:
15312 
      (fname, ftype, fid) = iprot.readFieldBegin()
15313 
      if ftype == TType.STOP:
15314 
        break
15315 
      if fid == 0:
15316 
        if ftype == TType.BOOL:
15317 
          self.success = iprot.readBool();
15318 
        else:
15319 
          iprot.skip(ftype)
15320 
      elif fid == 1:
15321 
        if ftype == TType.STRUCT:
15322 
          self.ex = TransactionServiceException()
15323 
          self.ex.read(iprot)
15324 
        else:
15325 
          iprot.skip(ftype)
15326 
      else:
15327 
        iprot.skip(ftype)
15328 
      iprot.readFieldEnd()
15329 
    iprot.readStructEnd()
15330 
 
15331 
  def write(self, oprot):
15332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15334 
      return
15335 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15336 
    if self.success is not None:
15337 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15338 
      oprot.writeBool(self.success)
15339 
      oprot.writeFieldEnd()
15340 
    if self.ex is not None:
15341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15342 
      self.ex.write(oprot)
15343 
      oprot.writeFieldEnd()
15344 
    oprot.writeFieldStop()
15345 
    oprot.writeStructEnd()
15346 
 
15347 
  def validate(self):
15348 
    return
15349 
 
15350 
 
15351 
  def __repr__(self):
15352 
    L = ['%s=%r' % (key, value)
15353 
      for key, value in self.__dict__.iteritems()]
15354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15355 
 
15356 
  def __eq__(self, other):
15357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15358 
 
15359 
  def __ne__(self, other):
15360 
    return not (self == other)
15361 
 
2536 chandransh 15362 
class requestPickupNumber_args:
15363 
  """
15364 
  Attributes:
15365 
   - orderId
4579 rajveer 15366 
   - providerId
2536 chandransh 15367 
  """
15368 
 
15369 
  thrift_spec = (
15370 
    None, # 0
15371 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15372 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15373 
  )
15374 
 
4579 rajveer 15375 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15376 
    self.orderId = orderId
4579 rajveer 15377 
    self.providerId = providerId
2536 chandransh 15378 
 
15379 
  def read(self, iprot):
15380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15382 
      return
15383 
    iprot.readStructBegin()
15384 
    while True:
15385 
      (fname, ftype, fid) = iprot.readFieldBegin()
15386 
      if ftype == TType.STOP:
15387 
        break
15388 
      if fid == 1:
15389 
        if ftype == TType.I64:
15390 
          self.orderId = iprot.readI64();
15391 
        else:
15392 
          iprot.skip(ftype)
4579 rajveer 15393 
      elif fid == 2:
15394 
        if ftype == TType.I64:
15395 
          self.providerId = iprot.readI64();
15396 
        else:
15397 
          iprot.skip(ftype)
2536 chandransh 15398 
      else:
15399 
        iprot.skip(ftype)
15400 
      iprot.readFieldEnd()
15401 
    iprot.readStructEnd()
15402 
 
15403 
  def write(self, oprot):
15404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15406 
      return
15407 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15408 
    if self.orderId is not None:
2536 chandransh 15409 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15410 
      oprot.writeI64(self.orderId)
15411 
      oprot.writeFieldEnd()
4579 rajveer 15412 
    if self.providerId is not None:
15413 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15414 
      oprot.writeI64(self.providerId)
15415 
      oprot.writeFieldEnd()
2536 chandransh 15416 
    oprot.writeFieldStop()
15417 
    oprot.writeStructEnd()
15418 
 
3431 rajveer 15419 
  def validate(self):
15420 
    return
15421 
 
15422 
 
2536 chandransh 15423 
  def __repr__(self):
15424 
    L = ['%s=%r' % (key, value)
15425 
      for key, value in self.__dict__.iteritems()]
15426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15427 
 
15428 
  def __eq__(self, other):
15429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15430 
 
15431 
  def __ne__(self, other):
15432 
    return not (self == other)
15433 
 
15434 
class requestPickupNumber_result:
15435 
  """
15436 
  Attributes:
15437 
   - success
15438 
   - ex
15439 
  """
15440 
 
15441 
  thrift_spec = (
15442 
    (0, TType.BOOL, 'success', None, None, ), # 0
15443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15444 
  )
15445 
 
15446 
  def __init__(self, success=None, ex=None,):
15447 
    self.success = success
15448 
    self.ex = ex
15449 
 
15450 
  def read(self, iprot):
15451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15453 
      return
15454 
    iprot.readStructBegin()
15455 
    while True:
15456 
      (fname, ftype, fid) = iprot.readFieldBegin()
15457 
      if ftype == TType.STOP:
15458 
        break
15459 
      if fid == 0:
15460 
        if ftype == TType.BOOL:
15461 
          self.success = iprot.readBool();
15462 
        else:
15463 
          iprot.skip(ftype)
15464 
      elif fid == 1:
15465 
        if ftype == TType.STRUCT:
15466 
          self.ex = TransactionServiceException()
15467 
          self.ex.read(iprot)
15468 
        else:
15469 
          iprot.skip(ftype)
15470 
      else:
15471 
        iprot.skip(ftype)
15472 
      iprot.readFieldEnd()
15473 
    iprot.readStructEnd()
15474 
 
15475 
  def write(self, oprot):
15476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15478 
      return
15479 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15480 
    if self.success is not None:
2536 chandransh 15481 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15482 
      oprot.writeBool(self.success)
15483 
      oprot.writeFieldEnd()
3431 rajveer 15484 
    if self.ex is not None:
2536 chandransh 15485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15486 
      self.ex.write(oprot)
15487 
      oprot.writeFieldEnd()
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
3431 rajveer 15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
2536 chandransh 15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
15506 
class authorizePickup_args:
15507 
  """
15508 
  Attributes:
15509 
   - orderId
15510 
   - pickupNumber
4602 rajveer 15511 
   - providerId
2536 chandransh 15512 
  """
15513 
 
15514 
  thrift_spec = (
15515 
    None, # 0
15516 
    (1, TType.I64, 'orderId', None, None, ), # 1
15517 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15518 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15519 
  )
15520 
 
4602 rajveer 15521 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15522 
    self.orderId = orderId
15523 
    self.pickupNumber = pickupNumber
4602 rajveer 15524 
    self.providerId = providerId
2536 chandransh 15525 
 
15526 
  def read(self, iprot):
15527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15529 
      return
15530 
    iprot.readStructBegin()
15531 
    while True:
15532 
      (fname, ftype, fid) = iprot.readFieldBegin()
15533 
      if ftype == TType.STOP:
15534 
        break
15535 
      if fid == 1:
15536 
        if ftype == TType.I64:
15537 
          self.orderId = iprot.readI64();
15538 
        else:
15539 
          iprot.skip(ftype)
15540 
      elif fid == 2:
15541 
        if ftype == TType.STRING:
15542 
          self.pickupNumber = iprot.readString();
15543 
        else:
15544 
          iprot.skip(ftype)
4602 rajveer 15545 
      elif fid == 3:
15546 
        if ftype == TType.I64:
15547 
          self.providerId = iprot.readI64();
15548 
        else:
15549 
          iprot.skip(ftype)
2536 chandransh 15550 
      else:
15551 
        iprot.skip(ftype)
15552 
      iprot.readFieldEnd()
15553 
    iprot.readStructEnd()
15554 
 
15555 
  def write(self, oprot):
15556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15558 
      return
15559 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15560 
    if self.orderId is not None:
2536 chandransh 15561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15562 
      oprot.writeI64(self.orderId)
15563 
      oprot.writeFieldEnd()
3431 rajveer 15564 
    if self.pickupNumber is not None:
2536 chandransh 15565 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15566 
      oprot.writeString(self.pickupNumber)
15567 
      oprot.writeFieldEnd()
4602 rajveer 15568 
    if self.providerId is not None:
15569 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15570 
      oprot.writeI64(self.providerId)
15571 
      oprot.writeFieldEnd()
2536 chandransh 15572 
    oprot.writeFieldStop()
15573 
    oprot.writeStructEnd()
15574 
 
3431 rajveer 15575 
  def validate(self):
15576 
    return
15577 
 
15578 
 
2536 chandransh 15579 
  def __repr__(self):
15580 
    L = ['%s=%r' % (key, value)
15581 
      for key, value in self.__dict__.iteritems()]
15582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15583 
 
15584 
  def __eq__(self, other):
15585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15586 
 
15587 
  def __ne__(self, other):
15588 
    return not (self == other)
15589 
 
15590 
class authorizePickup_result:
15591 
  """
15592 
  Attributes:
15593 
   - success
15594 
   - ex
15595 
  """
15596 
 
15597 
  thrift_spec = (
15598 
    (0, TType.BOOL, 'success', None, None, ), # 0
15599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15600 
  )
15601 
 
15602 
  def __init__(self, success=None, ex=None,):
15603 
    self.success = success
15604 
    self.ex = ex
15605 
 
15606 
  def read(self, iprot):
15607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15609 
      return
15610 
    iprot.readStructBegin()
15611 
    while True:
15612 
      (fname, ftype, fid) = iprot.readFieldBegin()
15613 
      if ftype == TType.STOP:
15614 
        break
15615 
      if fid == 0:
15616 
        if ftype == TType.BOOL:
15617 
          self.success = iprot.readBool();
15618 
        else:
15619 
          iprot.skip(ftype)
15620 
      elif fid == 1:
15621 
        if ftype == TType.STRUCT:
15622 
          self.ex = TransactionServiceException()
15623 
          self.ex.read(iprot)
15624 
        else:
15625 
          iprot.skip(ftype)
15626 
      else:
15627 
        iprot.skip(ftype)
15628 
      iprot.readFieldEnd()
15629 
    iprot.readStructEnd()
15630 
 
15631 
  def write(self, oprot):
15632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15634 
      return
15635 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15636 
    if self.success is not None:
2536 chandransh 15637 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15638 
      oprot.writeBool(self.success)
15639 
      oprot.writeFieldEnd()
3431 rajveer 15640 
    if self.ex is not None:
2536 chandransh 15641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15642 
      self.ex.write(oprot)
15643 
      oprot.writeFieldEnd()
15644 
    oprot.writeFieldStop()
15645 
    oprot.writeStructEnd()
15646 
 
3431 rajveer 15647 
  def validate(self):
15648 
    return
15649 
 
15650 
 
2536 chandransh 15651 
  def __repr__(self):
15652 
    L = ['%s=%r' % (key, value)
15653 
      for key, value in self.__dict__.iteritems()]
15654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15655 
 
15656 
  def __eq__(self, other):
15657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15658 
 
15659 
  def __ne__(self, other):
15660 
    return not (self == other)
15661 
 
2764 chandransh 15662 
class markDoasAsPickedUp_args:
15663 
  """
15664 
  Attributes:
15665 
   - providerId
15666 
   - pickupDetails
15667 
  """
15668 
 
15669 
  thrift_spec = (
15670 
    None, # 0
15671 
    (1, TType.I64, 'providerId', None, None, ), # 1
15672 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15673 
  )
15674 
 
15675 
  def __init__(self, providerId=None, pickupDetails=None,):
15676 
    self.providerId = providerId
15677 
    self.pickupDetails = pickupDetails
15678 
 
15679 
  def read(self, iprot):
15680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15682 
      return
15683 
    iprot.readStructBegin()
15684 
    while True:
15685 
      (fname, ftype, fid) = iprot.readFieldBegin()
15686 
      if ftype == TType.STOP:
15687 
        break
15688 
      if fid == 1:
15689 
        if ftype == TType.I64:
15690 
          self.providerId = iprot.readI64();
15691 
        else:
15692 
          iprot.skip(ftype)
15693 
      elif fid == 2:
15694 
        if ftype == TType.MAP:
15695 
          self.pickupDetails = {}
5411 rajveer 15696 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15697 
          for _i354 in xrange(_size350):
15698 
            _key355 = iprot.readString();
15699 
            _val356 = iprot.readString();
15700 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15701 
          iprot.readMapEnd()
15702 
        else:
15703 
          iprot.skip(ftype)
15704 
      else:
15705 
        iprot.skip(ftype)
15706 
      iprot.readFieldEnd()
15707 
    iprot.readStructEnd()
15708 
 
15709 
  def write(self, oprot):
15710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15712 
      return
15713 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15714 
    if self.providerId is not None:
2764 chandransh 15715 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15716 
      oprot.writeI64(self.providerId)
15717 
      oprot.writeFieldEnd()
3431 rajveer 15718 
    if self.pickupDetails is not None:
2764 chandransh 15719 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15720 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15721 
      for kiter357,viter358 in self.pickupDetails.items():
15722 
        oprot.writeString(kiter357)
15723 
        oprot.writeString(viter358)
2764 chandransh 15724 
      oprot.writeMapEnd()
15725 
      oprot.writeFieldEnd()
15726 
    oprot.writeFieldStop()
15727 
    oprot.writeStructEnd()
15728 
 
3431 rajveer 15729 
  def validate(self):
15730 
    return
15731 
 
15732 
 
2764 chandransh 15733 
  def __repr__(self):
15734 
    L = ['%s=%r' % (key, value)
15735 
      for key, value in self.__dict__.iteritems()]
15736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15737 
 
15738 
  def __eq__(self, other):
15739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15740 
 
15741 
  def __ne__(self, other):
15742 
    return not (self == other)
15743 
 
15744 
class markDoasAsPickedUp_result:
4910 phani.kuma 15745 
 
15746 
  thrift_spec = (
15747 
  )
15748 
 
15749 
  def read(self, iprot):
15750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15752 
      return
15753 
    iprot.readStructBegin()
15754 
    while True:
15755 
      (fname, ftype, fid) = iprot.readFieldBegin()
15756 
      if ftype == TType.STOP:
15757 
        break
15758 
      else:
15759 
        iprot.skip(ftype)
15760 
      iprot.readFieldEnd()
15761 
    iprot.readStructEnd()
15762 
 
15763 
  def write(self, oprot):
15764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15766 
      return
15767 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15768 
    oprot.writeFieldStop()
15769 
    oprot.writeStructEnd()
15770 
 
15771 
  def validate(self):
15772 
    return
15773 
 
15774 
 
15775 
  def __repr__(self):
15776 
    L = ['%s=%r' % (key, value)
15777 
      for key, value in self.__dict__.iteritems()]
15778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15779 
 
15780 
  def __eq__(self, other):
15781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15782 
 
15783 
  def __ne__(self, other):
15784 
    return not (self == other)
15785 
 
15786 
class getDoasNotPickedUp_args:
2764 chandransh 15787 
  """
15788 
  Attributes:
4910 phani.kuma 15789 
   - providerId
15790 
  """
15791 
 
15792 
  thrift_spec = (
15793 
    None, # 0
15794 
    (1, TType.I64, 'providerId', None, None, ), # 1
15795 
  )
15796 
 
15797 
  def __init__(self, providerId=None,):
15798 
    self.providerId = providerId
15799 
 
15800 
  def read(self, iprot):
15801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15803 
      return
15804 
    iprot.readStructBegin()
15805 
    while True:
15806 
      (fname, ftype, fid) = iprot.readFieldBegin()
15807 
      if ftype == TType.STOP:
15808 
        break
15809 
      if fid == 1:
15810 
        if ftype == TType.I64:
15811 
          self.providerId = iprot.readI64();
15812 
        else:
15813 
          iprot.skip(ftype)
15814 
      else:
15815 
        iprot.skip(ftype)
15816 
      iprot.readFieldEnd()
15817 
    iprot.readStructEnd()
15818 
 
15819 
  def write(self, oprot):
15820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15822 
      return
15823 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15824 
    if self.providerId is not None:
15825 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15826 
      oprot.writeI64(self.providerId)
15827 
      oprot.writeFieldEnd()
15828 
    oprot.writeFieldStop()
15829 
    oprot.writeStructEnd()
15830 
 
15831 
  def validate(self):
15832 
    return
15833 
 
15834 
 
15835 
  def __repr__(self):
15836 
    L = ['%s=%r' % (key, value)
15837 
      for key, value in self.__dict__.iteritems()]
15838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15839 
 
15840 
  def __eq__(self, other):
15841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15842 
 
15843 
  def __ne__(self, other):
15844 
    return not (self == other)
15845 
 
15846 
class getDoasNotPickedUp_result:
15847 
  """
15848 
  Attributes:
2764 chandransh 15849 
   - success
15850 
  """
15851 
 
15852 
  thrift_spec = (
15853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15854 
  )
15855 
 
15856 
  def __init__(self, success=None,):
15857 
    self.success = success
15858 
 
15859 
  def read(self, iprot):
15860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15862 
      return
15863 
    iprot.readStructBegin()
15864 
    while True:
15865 
      (fname, ftype, fid) = iprot.readFieldBegin()
15866 
      if ftype == TType.STOP:
15867 
        break
15868 
      if fid == 0:
15869 
        if ftype == TType.LIST:
15870 
          self.success = []
5411 rajveer 15871 
          (_etype362, _size359) = iprot.readListBegin()
15872 
          for _i363 in xrange(_size359):
15873 
            _elem364 = Order()
15874 
            _elem364.read(iprot)
15875 
            self.success.append(_elem364)
2764 chandransh 15876 
          iprot.readListEnd()
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
4910 phani.kuma 15888 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15889 
    if self.success is not None:
2764 chandransh 15890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15892 
      for iter365 in self.success:
15893 
        iter365.write(oprot)
2764 chandransh 15894 
      oprot.writeListEnd()
15895 
      oprot.writeFieldEnd()
15896 
    oprot.writeFieldStop()
15897 
    oprot.writeStructEnd()
15898 
 
3431 rajveer 15899 
  def validate(self):
15900 
    return
15901 
 
15902 
 
2764 chandransh 15903 
  def __repr__(self):
15904 
    L = ['%s=%r' % (key, value)
15905 
      for key, value in self.__dict__.iteritems()]
15906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15907 
 
15908 
  def __eq__(self, other):
15909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15910 
 
15911 
  def __ne__(self, other):
15912 
    return not (self == other)
15913 
 
4741 phani.kuma 15914 
class markReturnOrdersAsPickedUp_args:
15915 
  """
15916 
  Attributes:
15917 
   - providerId
15918 
   - pickupDetails
15919 
  """
15920 
 
15921 
  thrift_spec = (
15922 
    None, # 0
15923 
    (1, TType.I64, 'providerId', None, None, ), # 1
15924 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15925 
  )
15926 
 
15927 
  def __init__(self, providerId=None, pickupDetails=None,):
15928 
    self.providerId = providerId
15929 
    self.pickupDetails = pickupDetails
15930 
 
15931 
  def read(self, iprot):
15932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15934 
      return
15935 
    iprot.readStructBegin()
15936 
    while True:
15937 
      (fname, ftype, fid) = iprot.readFieldBegin()
15938 
      if ftype == TType.STOP:
15939 
        break
15940 
      if fid == 1:
15941 
        if ftype == TType.I64:
15942 
          self.providerId = iprot.readI64();
15943 
        else:
15944 
          iprot.skip(ftype)
15945 
      elif fid == 2:
15946 
        if ftype == TType.MAP:
15947 
          self.pickupDetails = {}
5411 rajveer 15948 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
15949 
          for _i370 in xrange(_size366):
15950 
            _key371 = iprot.readString();
15951 
            _val372 = iprot.readString();
15952 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 15953 
          iprot.readMapEnd()
15954 
        else:
15955 
          iprot.skip(ftype)
15956 
      else:
15957 
        iprot.skip(ftype)
15958 
      iprot.readFieldEnd()
15959 
    iprot.readStructEnd()
15960 
 
15961 
  def write(self, oprot):
15962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15964 
      return
15965 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15966 
    if self.providerId is not None:
15967 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15968 
      oprot.writeI64(self.providerId)
15969 
      oprot.writeFieldEnd()
15970 
    if self.pickupDetails is not None:
15971 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15972 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15973 
      for kiter373,viter374 in self.pickupDetails.items():
15974 
        oprot.writeString(kiter373)
15975 
        oprot.writeString(viter374)
4741 phani.kuma 15976 
      oprot.writeMapEnd()
15977 
      oprot.writeFieldEnd()
15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
15996 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15997 
 
15998 
  thrift_spec = (
15999 
  )
16000 
 
16001 
  def read(self, iprot):
16002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16004 
      return
16005 
    iprot.readStructBegin()
16006 
    while True:
16007 
      (fname, ftype, fid) = iprot.readFieldBegin()
16008 
      if ftype == TType.STOP:
16009 
        break
16010 
      else:
16011 
        iprot.skip(ftype)
16012 
      iprot.readFieldEnd()
16013 
    iprot.readStructEnd()
16014 
 
16015 
  def write(self, oprot):
16016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16018 
      return
16019 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16020 
    oprot.writeFieldStop()
16021 
    oprot.writeStructEnd()
16022 
 
16023 
  def validate(self):
16024 
    return
16025 
 
16026 
 
16027 
  def __repr__(self):
16028 
    L = ['%s=%r' % (key, value)
16029 
      for key, value in self.__dict__.iteritems()]
16030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16031 
 
16032 
  def __eq__(self, other):
16033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16034 
 
16035 
  def __ne__(self, other):
16036 
    return not (self == other)
16037 
 
16038 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16039 
  """
16040 
  Attributes:
4910 phani.kuma 16041 
   - providerId
16042 
  """
16043 
 
16044 
  thrift_spec = (
16045 
    None, # 0
16046 
    (1, TType.I64, 'providerId', None, None, ), # 1
16047 
  )
16048 
 
16049 
  def __init__(self, providerId=None,):
16050 
    self.providerId = providerId
16051 
 
16052 
  def read(self, iprot):
16053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16055 
      return
16056 
    iprot.readStructBegin()
16057 
    while True:
16058 
      (fname, ftype, fid) = iprot.readFieldBegin()
16059 
      if ftype == TType.STOP:
16060 
        break
16061 
      if fid == 1:
16062 
        if ftype == TType.I64:
16063 
          self.providerId = iprot.readI64();
16064 
        else:
16065 
          iprot.skip(ftype)
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16076 
    if self.providerId is not None:
16077 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16078 
      oprot.writeI64(self.providerId)
16079 
      oprot.writeFieldEnd()
16080 
    oprot.writeFieldStop()
16081 
    oprot.writeStructEnd()
16082 
 
16083 
  def validate(self):
16084 
    return
16085 
 
16086 
 
16087 
  def __repr__(self):
16088 
    L = ['%s=%r' % (key, value)
16089 
      for key, value in self.__dict__.iteritems()]
16090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16091 
 
16092 
  def __eq__(self, other):
16093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16094 
 
16095 
  def __ne__(self, other):
16096 
    return not (self == other)
16097 
 
16098 
class getReturnOrdersNotPickedUp_result:
16099 
  """
16100 
  Attributes:
4741 phani.kuma 16101 
   - success
16102 
  """
16103 
 
16104 
  thrift_spec = (
16105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16106 
  )
16107 
 
16108 
  def __init__(self, success=None,):
16109 
    self.success = success
16110 
 
16111 
  def read(self, iprot):
16112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16114 
      return
16115 
    iprot.readStructBegin()
16116 
    while True:
16117 
      (fname, ftype, fid) = iprot.readFieldBegin()
16118 
      if ftype == TType.STOP:
16119 
        break
16120 
      if fid == 0:
16121 
        if ftype == TType.LIST:
16122 
          self.success = []
5411 rajveer 16123 
          (_etype378, _size375) = iprot.readListBegin()
16124 
          for _i379 in xrange(_size375):
16125 
            _elem380 = Order()
16126 
            _elem380.read(iprot)
16127 
            self.success.append(_elem380)
4741 phani.kuma 16128 
          iprot.readListEnd()
16129 
        else:
16130 
          iprot.skip(ftype)
16131 
      else:
16132 
        iprot.skip(ftype)
16133 
      iprot.readFieldEnd()
16134 
    iprot.readStructEnd()
16135 
 
16136 
  def write(self, oprot):
16137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16139 
      return
4910 phani.kuma 16140 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16141 
    if self.success is not None:
16142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16143 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16144 
      for iter381 in self.success:
16145 
        iter381.write(oprot)
4741 phani.kuma 16146 
      oprot.writeListEnd()
16147 
      oprot.writeFieldEnd()
16148 
    oprot.writeFieldStop()
16149 
    oprot.writeStructEnd()
16150 
 
16151 
  def validate(self):
16152 
    return
16153 
 
16154 
 
16155 
  def __repr__(self):
16156 
    L = ['%s=%r' % (key, value)
16157 
      for key, value in self.__dict__.iteritems()]
16158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16159 
 
16160 
  def __eq__(self, other):
16161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16162 
 
16163 
  def __ne__(self, other):
16164 
    return not (self == other)
16165 
 
2616 chandransh 16166 
class receiveReturn_args:
2591 chandransh 16167 
  """
16168 
  Attributes:
16169 
   - orderId
4479 rajveer 16170 
   - receiveCondition
2591 chandransh 16171 
  """
2536 chandransh 16172 
 
2591 chandransh 16173 
  thrift_spec = (
16174 
    None, # 0
16175 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16176 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16177 
  )
16178 
 
4479 rajveer 16179 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16180 
    self.orderId = orderId
4479 rajveer 16181 
    self.receiveCondition = receiveCondition
2591 chandransh 16182 
 
16183 
  def read(self, iprot):
16184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16186 
      return
16187 
    iprot.readStructBegin()
16188 
    while True:
16189 
      (fname, ftype, fid) = iprot.readFieldBegin()
16190 
      if ftype == TType.STOP:
16191 
        break
16192 
      if fid == 1:
16193 
        if ftype == TType.I64:
16194 
          self.orderId = iprot.readI64();
16195 
        else:
16196 
          iprot.skip(ftype)
4479 rajveer 16197 
      elif fid == 2:
16198 
        if ftype == TType.I64:
16199 
          self.receiveCondition = iprot.readI64();
16200 
        else:
16201 
          iprot.skip(ftype)
2591 chandransh 16202 
      else:
16203 
        iprot.skip(ftype)
16204 
      iprot.readFieldEnd()
16205 
    iprot.readStructEnd()
16206 
 
16207 
  def write(self, oprot):
16208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16210 
      return
2616 chandransh 16211 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16212 
    if self.orderId is not None:
2591 chandransh 16213 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16214 
      oprot.writeI64(self.orderId)
16215 
      oprot.writeFieldEnd()
4479 rajveer 16216 
    if self.receiveCondition is not None:
16217 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16218 
      oprot.writeI64(self.receiveCondition)
16219 
      oprot.writeFieldEnd()
2591 chandransh 16220 
    oprot.writeFieldStop()
16221 
    oprot.writeStructEnd()
16222 
 
3431 rajveer 16223 
  def validate(self):
16224 
    return
16225 
 
16226 
 
2591 chandransh 16227 
  def __repr__(self):
16228 
    L = ['%s=%r' % (key, value)
16229 
      for key, value in self.__dict__.iteritems()]
16230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16231 
 
16232 
  def __eq__(self, other):
16233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16234 
 
16235 
  def __ne__(self, other):
16236 
    return not (self == other)
16237 
 
2616 chandransh 16238 
class receiveReturn_result:
2591 chandransh 16239 
  """
16240 
  Attributes:
16241 
   - success
16242 
   - ex
16243 
  """
16244 
 
16245 
  thrift_spec = (
16246 
    (0, TType.BOOL, 'success', None, None, ), # 0
16247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16248 
  )
16249 
 
16250 
  def __init__(self, success=None, ex=None,):
16251 
    self.success = success
16252 
    self.ex = ex
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      if fid == 0:
16264 
        if ftype == TType.BOOL:
16265 
          self.success = iprot.readBool();
16266 
        else:
16267 
          iprot.skip(ftype)
16268 
      elif fid == 1:
16269 
        if ftype == TType.STRUCT:
16270 
          self.ex = TransactionServiceException()
16271 
          self.ex.read(iprot)
16272 
        else:
16273 
          iprot.skip(ftype)
16274 
      else:
16275 
        iprot.skip(ftype)
16276 
      iprot.readFieldEnd()
16277 
    iprot.readStructEnd()
16278 
 
16279 
  def write(self, oprot):
16280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16282 
      return
2616 chandransh 16283 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16284 
    if self.success is not None:
2591 chandransh 16285 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16286 
      oprot.writeBool(self.success)
16287 
      oprot.writeFieldEnd()
3431 rajveer 16288 
    if self.ex is not None:
2591 chandransh 16289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16290 
      self.ex.write(oprot)
16291 
      oprot.writeFieldEnd()
16292 
    oprot.writeFieldStop()
16293 
    oprot.writeStructEnd()
16294 
 
3431 rajveer 16295 
  def validate(self):
16296 
    return
16297 
 
16298 
 
2591 chandransh 16299 
  def __repr__(self):
16300 
    L = ['%s=%r' % (key, value)
16301 
      for key, value in self.__dict__.iteritems()]
16302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16303 
 
16304 
  def __eq__(self, other):
16305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16306 
 
16307 
  def __ne__(self, other):
16308 
    return not (self == other)
16309 
 
16310 
class validateDoa_args:
16311 
  """
16312 
  Attributes:
16313 
   - orderId
16314 
   - isValid
16315 
  """
16316 
 
16317 
  thrift_spec = (
16318 
    None, # 0
16319 
    (1, TType.I64, 'orderId', None, None, ), # 1
16320 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16321 
  )
16322 
 
16323 
  def __init__(self, orderId=None, isValid=None,):
16324 
    self.orderId = orderId
16325 
    self.isValid = isValid
16326 
 
16327 
  def read(self, iprot):
16328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16330 
      return
16331 
    iprot.readStructBegin()
16332 
    while True:
16333 
      (fname, ftype, fid) = iprot.readFieldBegin()
16334 
      if ftype == TType.STOP:
16335 
        break
16336 
      if fid == 1:
16337 
        if ftype == TType.I64:
16338 
          self.orderId = iprot.readI64();
16339 
        else:
16340 
          iprot.skip(ftype)
16341 
      elif fid == 2:
16342 
        if ftype == TType.BOOL:
16343 
          self.isValid = iprot.readBool();
16344 
        else:
16345 
          iprot.skip(ftype)
16346 
      else:
16347 
        iprot.skip(ftype)
16348 
      iprot.readFieldEnd()
16349 
    iprot.readStructEnd()
16350 
 
16351 
  def write(self, oprot):
16352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16354 
      return
16355 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16356 
    if self.orderId is not None:
2591 chandransh 16357 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16358 
      oprot.writeI64(self.orderId)
16359 
      oprot.writeFieldEnd()
3431 rajveer 16360 
    if self.isValid is not None:
2591 chandransh 16361 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16362 
      oprot.writeBool(self.isValid)
16363 
      oprot.writeFieldEnd()
16364 
    oprot.writeFieldStop()
16365 
    oprot.writeStructEnd()
16366 
 
3431 rajveer 16367 
  def validate(self):
16368 
    return
16369 
 
16370 
 
2591 chandransh 16371 
  def __repr__(self):
16372 
    L = ['%s=%r' % (key, value)
16373 
      for key, value in self.__dict__.iteritems()]
16374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16375 
 
16376 
  def __eq__(self, other):
16377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16378 
 
16379 
  def __ne__(self, other):
16380 
    return not (self == other)
16381 
 
16382 
class validateDoa_result:
16383 
  """
16384 
  Attributes:
16385 
   - success
16386 
   - ex
16387 
  """
16388 
 
16389 
  thrift_spec = (
16390 
    (0, TType.BOOL, 'success', None, None, ), # 0
16391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16392 
  )
16393 
 
16394 
  def __init__(self, success=None, ex=None,):
16395 
    self.success = success
16396 
    self.ex = ex
16397 
 
16398 
  def read(self, iprot):
16399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16401 
      return
16402 
    iprot.readStructBegin()
16403 
    while True:
16404 
      (fname, ftype, fid) = iprot.readFieldBegin()
16405 
      if ftype == TType.STOP:
16406 
        break
16407 
      if fid == 0:
16408 
        if ftype == TType.BOOL:
16409 
          self.success = iprot.readBool();
16410 
        else:
16411 
          iprot.skip(ftype)
16412 
      elif fid == 1:
16413 
        if ftype == TType.STRUCT:
16414 
          self.ex = TransactionServiceException()
16415 
          self.ex.read(iprot)
16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      else:
16419 
        iprot.skip(ftype)
16420 
      iprot.readFieldEnd()
16421 
    iprot.readStructEnd()
16422 
 
16423 
  def write(self, oprot):
16424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16426 
      return
16427 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16428 
    if self.success is not None:
2591 chandransh 16429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16430 
      oprot.writeBool(self.success)
16431 
      oprot.writeFieldEnd()
3431 rajveer 16432 
    if self.ex is not None:
2591 chandransh 16433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16434 
      self.ex.write(oprot)
16435 
      oprot.writeFieldEnd()
16436 
    oprot.writeFieldStop()
16437 
    oprot.writeStructEnd()
16438 
 
3431 rajveer 16439 
  def validate(self):
16440 
    return
16441 
 
16442 
 
2591 chandransh 16443 
  def __repr__(self):
16444 
    L = ['%s=%r' % (key, value)
16445 
      for key, value in self.__dict__.iteritems()]
16446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16447 
 
16448 
  def __eq__(self, other):
16449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16450 
 
16451 
  def __ne__(self, other):
16452 
    return not (self == other)
16453 
 
4495 rajveer 16454 
class validateReturnProduct_args:
16455 
  """
16456 
  Attributes:
16457 
   - orderId
16458 
   - isUsable
16459 
  """
16460 
 
16461 
  thrift_spec = (
16462 
    None, # 0
16463 
    (1, TType.I64, 'orderId', None, None, ), # 1
16464 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16465 
  )
16466 
 
16467 
  def __init__(self, orderId=None, isUsable=None,):
16468 
    self.orderId = orderId
16469 
    self.isUsable = isUsable
16470 
 
16471 
  def read(self, iprot):
16472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16474 
      return
16475 
    iprot.readStructBegin()
16476 
    while True:
16477 
      (fname, ftype, fid) = iprot.readFieldBegin()
16478 
      if ftype == TType.STOP:
16479 
        break
16480 
      if fid == 1:
16481 
        if ftype == TType.I64:
16482 
          self.orderId = iprot.readI64();
16483 
        else:
16484 
          iprot.skip(ftype)
16485 
      elif fid == 2:
16486 
        if ftype == TType.BOOL:
16487 
          self.isUsable = iprot.readBool();
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('validateReturnProduct_args')
16500 
    if self.orderId is not None:
16501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16502 
      oprot.writeI64(self.orderId)
16503 
      oprot.writeFieldEnd()
16504 
    if self.isUsable is not None:
16505 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16506 
      oprot.writeBool(self.isUsable)
16507 
      oprot.writeFieldEnd()
16508 
    oprot.writeFieldStop()
16509 
    oprot.writeStructEnd()
16510 
 
16511 
  def validate(self):
16512 
    return
16513 
 
16514 
 
16515 
  def __repr__(self):
16516 
    L = ['%s=%r' % (key, value)
16517 
      for key, value in self.__dict__.iteritems()]
16518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16519 
 
16520 
  def __eq__(self, other):
16521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16522 
 
16523 
  def __ne__(self, other):
16524 
    return not (self == other)
16525 
 
16526 
class validateReturnProduct_result:
16527 
  """
16528 
  Attributes:
16529 
   - success
16530 
   - ex
16531 
  """
16532 
 
16533 
  thrift_spec = (
16534 
    (0, TType.BOOL, 'success', None, None, ), # 0
16535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16536 
  )
16537 
 
16538 
  def __init__(self, success=None, ex=None,):
16539 
    self.success = success
16540 
    self.ex = ex
16541 
 
16542 
  def read(self, iprot):
16543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16545 
      return
16546 
    iprot.readStructBegin()
16547 
    while True:
16548 
      (fname, ftype, fid) = iprot.readFieldBegin()
16549 
      if ftype == TType.STOP:
16550 
        break
16551 
      if fid == 0:
16552 
        if ftype == TType.BOOL:
16553 
          self.success = iprot.readBool();
16554 
        else:
16555 
          iprot.skip(ftype)
16556 
      elif fid == 1:
16557 
        if ftype == TType.STRUCT:
16558 
          self.ex = TransactionServiceException()
16559 
          self.ex.read(iprot)
16560 
        else:
16561 
          iprot.skip(ftype)
16562 
      else:
16563 
        iprot.skip(ftype)
16564 
      iprot.readFieldEnd()
16565 
    iprot.readStructEnd()
16566 
 
16567 
  def write(self, oprot):
16568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16570 
      return
16571 
    oprot.writeStructBegin('validateReturnProduct_result')
16572 
    if self.success is not None:
16573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16574 
      oprot.writeBool(self.success)
16575 
      oprot.writeFieldEnd()
16576 
    if self.ex is not None:
16577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16578 
      self.ex.write(oprot)
16579 
      oprot.writeFieldEnd()
16580 
    oprot.writeFieldStop()
16581 
    oprot.writeStructEnd()
16582 
 
16583 
  def validate(self):
16584 
    return
16585 
 
16586 
 
16587 
  def __repr__(self):
16588 
    L = ['%s=%r' % (key, value)
16589 
      for key, value in self.__dict__.iteritems()]
16590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16591 
 
16592 
  def __eq__(self, other):
16593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16594 
 
16595 
  def __ne__(self, other):
16596 
    return not (self == other)
16597 
 
2616 chandransh 16598 
class reshipOrder_args:
16599 
  """
16600 
  Attributes:
16601 
   - orderId
16602 
  """
2591 chandransh 16603 
 
2616 chandransh 16604 
  thrift_spec = (
16605 
    None, # 0
16606 
    (1, TType.I64, 'orderId', None, None, ), # 1
16607 
  )
16608 
 
16609 
  def __init__(self, orderId=None,):
16610 
    self.orderId = orderId
16611 
 
16612 
  def read(self, iprot):
16613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16615 
      return
16616 
    iprot.readStructBegin()
16617 
    while True:
16618 
      (fname, ftype, fid) = iprot.readFieldBegin()
16619 
      if ftype == TType.STOP:
16620 
        break
16621 
      if fid == 1:
16622 
        if ftype == TType.I64:
16623 
          self.orderId = iprot.readI64();
16624 
        else:
16625 
          iprot.skip(ftype)
16626 
      else:
16627 
        iprot.skip(ftype)
16628 
      iprot.readFieldEnd()
16629 
    iprot.readStructEnd()
16630 
 
16631 
  def write(self, oprot):
16632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16634 
      return
16635 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16636 
    if self.orderId is not None:
2616 chandransh 16637 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16638 
      oprot.writeI64(self.orderId)
16639 
      oprot.writeFieldEnd()
16640 
    oprot.writeFieldStop()
16641 
    oprot.writeStructEnd()
16642 
 
3431 rajveer 16643 
  def validate(self):
16644 
    return
16645 
 
16646 
 
2616 chandransh 16647 
  def __repr__(self):
16648 
    L = ['%s=%r' % (key, value)
16649 
      for key, value in self.__dict__.iteritems()]
16650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16651 
 
16652 
  def __eq__(self, other):
16653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16654 
 
16655 
  def __ne__(self, other):
16656 
    return not (self == other)
16657 
 
16658 
class reshipOrder_result:
16659 
  """
16660 
  Attributes:
16661 
   - success
16662 
   - ex
16663 
  """
16664 
 
16665 
  thrift_spec = (
16666 
    (0, TType.I64, 'success', None, None, ), # 0
16667 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16668 
  )
16669 
 
16670 
  def __init__(self, success=None, ex=None,):
16671 
    self.success = success
16672 
    self.ex = ex
16673 
 
16674 
  def read(self, iprot):
16675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16677 
      return
16678 
    iprot.readStructBegin()
16679 
    while True:
16680 
      (fname, ftype, fid) = iprot.readFieldBegin()
16681 
      if ftype == TType.STOP:
16682 
        break
16683 
      if fid == 0:
16684 
        if ftype == TType.I64:
16685 
          self.success = iprot.readI64();
16686 
        else:
16687 
          iprot.skip(ftype)
16688 
      elif fid == 1:
16689 
        if ftype == TType.STRUCT:
16690 
          self.ex = TransactionServiceException()
16691 
          self.ex.read(iprot)
16692 
        else:
16693 
          iprot.skip(ftype)
16694 
      else:
16695 
        iprot.skip(ftype)
16696 
      iprot.readFieldEnd()
16697 
    iprot.readStructEnd()
16698 
 
16699 
  def write(self, oprot):
16700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16702 
      return
16703 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16704 
    if self.success is not None:
2616 chandransh 16705 
      oprot.writeFieldBegin('success', TType.I64, 0)
16706 
      oprot.writeI64(self.success)
16707 
      oprot.writeFieldEnd()
3431 rajveer 16708 
    if self.ex is not None:
2616 chandransh 16709 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16710 
      self.ex.write(oprot)
16711 
      oprot.writeFieldEnd()
16712 
    oprot.writeFieldStop()
16713 
    oprot.writeStructEnd()
16714 
 
3431 rajveer 16715 
  def validate(self):
16716 
    return
16717 
 
16718 
 
2616 chandransh 16719 
  def __repr__(self):
16720 
    L = ['%s=%r' % (key, value)
16721 
      for key, value in self.__dict__.iteritems()]
16722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16723 
 
16724 
  def __eq__(self, other):
16725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16726 
 
16727 
  def __ne__(self, other):
16728 
    return not (self == other)
16729 
 
16730 
class refundOrder_args:
16731 
  """
16732 
  Attributes:
16733 
   - orderId
3226 chandransh 16734 
   - refundedBy
16735 
   - reason
2616 chandransh 16736 
  """
16737 
 
16738 
  thrift_spec = (
16739 
    None, # 0
16740 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16741 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16742 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16743 
  )
16744 
 
3226 chandransh 16745 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16746 
    self.orderId = orderId
3226 chandransh 16747 
    self.refundedBy = refundedBy
16748 
    self.reason = reason
2616 chandransh 16749 
 
16750 
  def read(self, iprot):
16751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16753 
      return
16754 
    iprot.readStructBegin()
16755 
    while True:
16756 
      (fname, ftype, fid) = iprot.readFieldBegin()
16757 
      if ftype == TType.STOP:
16758 
        break
16759 
      if fid == 1:
16760 
        if ftype == TType.I64:
16761 
          self.orderId = iprot.readI64();
16762 
        else:
16763 
          iprot.skip(ftype)
3226 chandransh 16764 
      elif fid == 2:
16765 
        if ftype == TType.STRING:
16766 
          self.refundedBy = iprot.readString();
16767 
        else:
16768 
          iprot.skip(ftype)
16769 
      elif fid == 3:
16770 
        if ftype == TType.STRING:
16771 
          self.reason = iprot.readString();
16772 
        else:
16773 
          iprot.skip(ftype)
2616 chandransh 16774 
      else:
16775 
        iprot.skip(ftype)
16776 
      iprot.readFieldEnd()
16777 
    iprot.readStructEnd()
16778 
 
16779 
  def write(self, oprot):
16780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16782 
      return
16783 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16784 
    if self.orderId is not None:
2616 chandransh 16785 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16786 
      oprot.writeI64(self.orderId)
16787 
      oprot.writeFieldEnd()
3431 rajveer 16788 
    if self.refundedBy is not None:
3226 chandransh 16789 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16790 
      oprot.writeString(self.refundedBy)
16791 
      oprot.writeFieldEnd()
3431 rajveer 16792 
    if self.reason is not None:
3226 chandransh 16793 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16794 
      oprot.writeString(self.reason)
16795 
      oprot.writeFieldEnd()
2616 chandransh 16796 
    oprot.writeFieldStop()
16797 
    oprot.writeStructEnd()
16798 
 
3431 rajveer 16799 
  def validate(self):
16800 
    return
16801 
 
16802 
 
2616 chandransh 16803 
  def __repr__(self):
16804 
    L = ['%s=%r' % (key, value)
16805 
      for key, value in self.__dict__.iteritems()]
16806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16807 
 
16808 
  def __eq__(self, other):
16809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16810 
 
16811 
  def __ne__(self, other):
16812 
    return not (self == other)
16813 
 
16814 
class refundOrder_result:
16815 
  """
16816 
  Attributes:
16817 
   - success
16818 
   - ex
16819 
  """
16820 
 
16821 
  thrift_spec = (
16822 
    (0, TType.BOOL, 'success', None, None, ), # 0
16823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16824 
  )
16825 
 
16826 
  def __init__(self, success=None, ex=None,):
16827 
    self.success = success
16828 
    self.ex = ex
16829 
 
16830 
  def read(self, iprot):
16831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16833 
      return
16834 
    iprot.readStructBegin()
16835 
    while True:
16836 
      (fname, ftype, fid) = iprot.readFieldBegin()
16837 
      if ftype == TType.STOP:
16838 
        break
16839 
      if fid == 0:
16840 
        if ftype == TType.BOOL:
16841 
          self.success = iprot.readBool();
16842 
        else:
16843 
          iprot.skip(ftype)
16844 
      elif fid == 1:
16845 
        if ftype == TType.STRUCT:
16846 
          self.ex = TransactionServiceException()
16847 
          self.ex.read(iprot)
16848 
        else:
16849 
          iprot.skip(ftype)
16850 
      else:
16851 
        iprot.skip(ftype)
16852 
      iprot.readFieldEnd()
16853 
    iprot.readStructEnd()
16854 
 
16855 
  def write(self, oprot):
16856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16858 
      return
16859 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16860 
    if self.success is not None:
2616 chandransh 16861 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16862 
      oprot.writeBool(self.success)
16863 
      oprot.writeFieldEnd()
3431 rajveer 16864 
    if self.ex is not None:
2616 chandransh 16865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16866 
      self.ex.write(oprot)
16867 
      oprot.writeFieldEnd()
16868 
    oprot.writeFieldStop()
16869 
    oprot.writeStructEnd()
16870 
 
3431 rajveer 16871 
  def validate(self):
16872 
    return
16873 
 
16874 
 
2616 chandransh 16875 
  def __repr__(self):
16876 
    L = ['%s=%r' % (key, value)
16877 
      for key, value in self.__dict__.iteritems()]
16878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16879 
 
16880 
  def __eq__(self, other):
16881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16882 
 
16883 
  def __ne__(self, other):
16884 
    return not (self == other)
16885 
 
2690 chandransh 16886 
class getReturnOrders_args:
16887 
  """
16888 
  Attributes:
16889 
   - warehouseId
16890 
   - fromDate
16891 
   - toDate
16892 
  """
2616 chandransh 16893 
 
2690 chandransh 16894 
  thrift_spec = (
16895 
    None, # 0
16896 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16897 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16898 
    (3, TType.I64, 'toDate', None, None, ), # 3
16899 
  )
16900 
 
16901 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16902 
    self.warehouseId = warehouseId
16903 
    self.fromDate = fromDate
16904 
    self.toDate = toDate
16905 
 
16906 
  def read(self, iprot):
16907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16909 
      return
16910 
    iprot.readStructBegin()
16911 
    while True:
16912 
      (fname, ftype, fid) = iprot.readFieldBegin()
16913 
      if ftype == TType.STOP:
16914 
        break
16915 
      if fid == 1:
16916 
        if ftype == TType.I64:
16917 
          self.warehouseId = iprot.readI64();
16918 
        else:
16919 
          iprot.skip(ftype)
16920 
      elif fid == 2:
16921 
        if ftype == TType.I64:
16922 
          self.fromDate = iprot.readI64();
16923 
        else:
16924 
          iprot.skip(ftype)
16925 
      elif fid == 3:
16926 
        if ftype == TType.I64:
16927 
          self.toDate = iprot.readI64();
16928 
        else:
16929 
          iprot.skip(ftype)
16930 
      else:
16931 
        iprot.skip(ftype)
16932 
      iprot.readFieldEnd()
16933 
    iprot.readStructEnd()
16934 
 
16935 
  def write(self, oprot):
16936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16938 
      return
16939 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16940 
    if self.warehouseId is not None:
2690 chandransh 16941 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16942 
      oprot.writeI64(self.warehouseId)
16943 
      oprot.writeFieldEnd()
3431 rajveer 16944 
    if self.fromDate is not None:
2690 chandransh 16945 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16946 
      oprot.writeI64(self.fromDate)
16947 
      oprot.writeFieldEnd()
3431 rajveer 16948 
    if self.toDate is not None:
2690 chandransh 16949 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16950 
      oprot.writeI64(self.toDate)
16951 
      oprot.writeFieldEnd()
16952 
    oprot.writeFieldStop()
16953 
    oprot.writeStructEnd()
16954 
 
3431 rajveer 16955 
  def validate(self):
16956 
    return
16957 
 
16958 
 
2690 chandransh 16959 
  def __repr__(self):
16960 
    L = ['%s=%r' % (key, value)
16961 
      for key, value in self.__dict__.iteritems()]
16962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16963 
 
16964 
  def __eq__(self, other):
16965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16966 
 
16967 
  def __ne__(self, other):
16968 
    return not (self == other)
16969 
 
16970 
class getReturnOrders_result:
16971 
  """
16972 
  Attributes:
16973 
   - success
16974 
  """
16975 
 
16976 
  thrift_spec = (
16977 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16978 
  )
16979 
 
16980 
  def __init__(self, success=None,):
16981 
    self.success = success
16982 
 
16983 
  def read(self, iprot):
16984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16986 
      return
16987 
    iprot.readStructBegin()
16988 
    while True:
16989 
      (fname, ftype, fid) = iprot.readFieldBegin()
16990 
      if ftype == TType.STOP:
16991 
        break
16992 
      if fid == 0:
16993 
        if ftype == TType.LIST:
16994 
          self.success = []
5411 rajveer 16995 
          (_etype385, _size382) = iprot.readListBegin()
16996 
          for _i386 in xrange(_size382):
16997 
            _elem387 = ReturnOrder()
16998 
            _elem387.read(iprot)
16999 
            self.success.append(_elem387)
2690 chandransh 17000 
          iprot.readListEnd()
17001 
        else:
17002 
          iprot.skip(ftype)
17003 
      else:
17004 
        iprot.skip(ftype)
17005 
      iprot.readFieldEnd()
17006 
    iprot.readStructEnd()
17007 
 
17008 
  def write(self, oprot):
17009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17011 
      return
17012 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17013 
    if self.success is not None:
2690 chandransh 17014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17015 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 17016 
      for iter388 in self.success:
17017 
        iter388.write(oprot)
2690 chandransh 17018 
      oprot.writeListEnd()
17019 
      oprot.writeFieldEnd()
17020 
    oprot.writeFieldStop()
17021 
    oprot.writeStructEnd()
17022 
 
3431 rajveer 17023 
  def validate(self):
17024 
    return
17025 
 
17026 
 
2690 chandransh 17027 
  def __repr__(self):
17028 
    L = ['%s=%r' % (key, value)
17029 
      for key, value in self.__dict__.iteritems()]
17030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17031 
 
17032 
  def __eq__(self, other):
17033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17034 
 
17035 
  def __ne__(self, other):
17036 
    return not (self == other)
17037 
 
5481 phani.kuma 17038 
class getAllReturnOrders_args:
17039 
  """
17040 
  Attributes:
17041 
   - onlyNotProcessed
17042 
   - fromDate
17043 
   - toDate
17044 
  """
17045 
 
17046 
  thrift_spec = (
17047 
    None, # 0
17048 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17049 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17050 
    (3, TType.I64, 'toDate', None, None, ), # 3
17051 
  )
17052 
 
17053 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17054 
    self.onlyNotProcessed = onlyNotProcessed
17055 
    self.fromDate = fromDate
17056 
    self.toDate = toDate
17057 
 
17058 
  def read(self, iprot):
17059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17061 
      return
17062 
    iprot.readStructBegin()
17063 
    while True:
17064 
      (fname, ftype, fid) = iprot.readFieldBegin()
17065 
      if ftype == TType.STOP:
17066 
        break
17067 
      if fid == 1:
17068 
        if ftype == TType.BOOL:
17069 
          self.onlyNotProcessed = iprot.readBool();
17070 
        else:
17071 
          iprot.skip(ftype)
17072 
      elif fid == 2:
17073 
        if ftype == TType.I64:
17074 
          self.fromDate = iprot.readI64();
17075 
        else:
17076 
          iprot.skip(ftype)
17077 
      elif fid == 3:
17078 
        if ftype == TType.I64:
17079 
          self.toDate = iprot.readI64();
17080 
        else:
17081 
          iprot.skip(ftype)
17082 
      else:
17083 
        iprot.skip(ftype)
17084 
      iprot.readFieldEnd()
17085 
    iprot.readStructEnd()
17086 
 
17087 
  def write(self, oprot):
17088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17090 
      return
17091 
    oprot.writeStructBegin('getAllReturnOrders_args')
17092 
    if self.onlyNotProcessed is not None:
17093 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17094 
      oprot.writeBool(self.onlyNotProcessed)
17095 
      oprot.writeFieldEnd()
17096 
    if self.fromDate is not None:
17097 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17098 
      oprot.writeI64(self.fromDate)
17099 
      oprot.writeFieldEnd()
17100 
    if self.toDate is not None:
17101 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17102 
      oprot.writeI64(self.toDate)
17103 
      oprot.writeFieldEnd()
17104 
    oprot.writeFieldStop()
17105 
    oprot.writeStructEnd()
17106 
 
17107 
  def validate(self):
17108 
    return
17109 
 
17110 
 
17111 
  def __repr__(self):
17112 
    L = ['%s=%r' % (key, value)
17113 
      for key, value in self.__dict__.iteritems()]
17114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17115 
 
17116 
  def __eq__(self, other):
17117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17118 
 
17119 
  def __ne__(self, other):
17120 
    return not (self == other)
17121 
 
17122 
class getAllReturnOrders_result:
17123 
  """
17124 
  Attributes:
17125 
   - success
17126 
  """
17127 
 
17128 
  thrift_spec = (
17129 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17130 
  )
17131 
 
17132 
  def __init__(self, success=None,):
17133 
    self.success = success
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.LIST:
17146 
          self.success = []
17147 
          (_etype392, _size389) = iprot.readListBegin()
17148 
          for _i393 in xrange(_size389):
17149 
            _elem394 = ReturnOrder()
17150 
            _elem394.read(iprot)
17151 
            self.success.append(_elem394)
17152 
          iprot.readListEnd()
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('getAllReturnOrders_result')
17165 
    if self.success is not None:
17166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17168 
      for iter395 in self.success:
17169 
        iter395.write(oprot)
17170 
      oprot.writeListEnd()
17171 
      oprot.writeFieldEnd()
17172 
    oprot.writeFieldStop()
17173 
    oprot.writeStructEnd()
17174 
 
17175 
  def validate(self):
17176 
    return
17177 
 
17178 
 
17179 
  def __repr__(self):
17180 
    L = ['%s=%r' % (key, value)
17181 
      for key, value in self.__dict__.iteritems()]
17182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17183 
 
17184 
  def __eq__(self, other):
17185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17186 
 
17187 
  def __ne__(self, other):
17188 
    return not (self == other)
17189 
 
2700 chandransh 17190 
class getReturnOrder_args:
17191 
  """
17192 
  Attributes:
17193 
   - id
17194 
  """
17195 
 
17196 
  thrift_spec = (
17197 
    None, # 0
17198 
    (1, TType.I64, 'id', None, None, ), # 1
17199 
  )
17200 
 
17201 
  def __init__(self, id=None,):
17202 
    self.id = id
17203 
 
17204 
  def read(self, iprot):
17205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17207 
      return
17208 
    iprot.readStructBegin()
17209 
    while True:
17210 
      (fname, ftype, fid) = iprot.readFieldBegin()
17211 
      if ftype == TType.STOP:
17212 
        break
17213 
      if fid == 1:
17214 
        if ftype == TType.I64:
17215 
          self.id = iprot.readI64();
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
17227 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17228 
    if self.id is not None:
2700 chandransh 17229 
      oprot.writeFieldBegin('id', TType.I64, 1)
17230 
      oprot.writeI64(self.id)
17231 
      oprot.writeFieldEnd()
17232 
    oprot.writeFieldStop()
17233 
    oprot.writeStructEnd()
17234 
 
3431 rajveer 17235 
  def validate(self):
17236 
    return
17237 
 
17238 
 
2700 chandransh 17239 
  def __repr__(self):
17240 
    L = ['%s=%r' % (key, value)
17241 
      for key, value in self.__dict__.iteritems()]
17242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17243 
 
17244 
  def __eq__(self, other):
17245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17246 
 
17247 
  def __ne__(self, other):
17248 
    return not (self == other)
17249 
 
17250 
class getReturnOrder_result:
17251 
  """
17252 
  Attributes:
17253 
   - success
17254 
   - ex
17255 
  """
17256 
 
17257 
  thrift_spec = (
17258 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17260 
  )
17261 
 
17262 
  def __init__(self, success=None, ex=None,):
17263 
    self.success = success
17264 
    self.ex = ex
17265 
 
17266 
  def read(self, iprot):
17267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17269 
      return
17270 
    iprot.readStructBegin()
17271 
    while True:
17272 
      (fname, ftype, fid) = iprot.readFieldBegin()
17273 
      if ftype == TType.STOP:
17274 
        break
17275 
      if fid == 0:
17276 
        if ftype == TType.STRUCT:
17277 
          self.success = ReturnOrder()
17278 
          self.success.read(iprot)
17279 
        else:
17280 
          iprot.skip(ftype)
17281 
      elif fid == 1:
17282 
        if ftype == TType.STRUCT:
17283 
          self.ex = TransactionServiceException()
17284 
          self.ex.read(iprot)
17285 
        else:
17286 
          iprot.skip(ftype)
17287 
      else:
17288 
        iprot.skip(ftype)
17289 
      iprot.readFieldEnd()
17290 
    iprot.readStructEnd()
17291 
 
17292 
  def write(self, oprot):
17293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17295 
      return
17296 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17297 
    if self.success is not None:
2700 chandransh 17298 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17299 
      self.success.write(oprot)
17300 
      oprot.writeFieldEnd()
3431 rajveer 17301 
    if self.ex is not None:
2700 chandransh 17302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17303 
      self.ex.write(oprot)
17304 
      oprot.writeFieldEnd()
17305 
    oprot.writeFieldStop()
17306 
    oprot.writeStructEnd()
17307 
 
3431 rajveer 17308 
  def validate(self):
17309 
    return
17310 
 
17311 
 
2700 chandransh 17312 
  def __repr__(self):
17313 
    L = ['%s=%r' % (key, value)
17314 
      for key, value in self.__dict__.iteritems()]
17315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17316 
 
17317 
  def __eq__(self, other):
17318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17319 
 
17320 
  def __ne__(self, other):
17321 
    return not (self == other)
17322 
 
2690 chandransh 17323 
class processReturn_args:
17324 
  """
17325 
  Attributes:
17326 
   - returnOrderId
17327 
  """
17328 
 
17329 
  thrift_spec = (
17330 
    None, # 0
17331 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17332 
  )
17333 
 
17334 
  def __init__(self, returnOrderId=None,):
17335 
    self.returnOrderId = returnOrderId
17336 
 
17337 
  def read(self, iprot):
17338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17340 
      return
17341 
    iprot.readStructBegin()
17342 
    while True:
17343 
      (fname, ftype, fid) = iprot.readFieldBegin()
17344 
      if ftype == TType.STOP:
17345 
        break
17346 
      if fid == 1:
17347 
        if ftype == TType.I64:
17348 
          self.returnOrderId = iprot.readI64();
17349 
        else:
17350 
          iprot.skip(ftype)
17351 
      else:
17352 
        iprot.skip(ftype)
17353 
      iprot.readFieldEnd()
17354 
    iprot.readStructEnd()
17355 
 
17356 
  def write(self, oprot):
17357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17359 
      return
17360 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17361 
    if self.returnOrderId is not None:
2690 chandransh 17362 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17363 
      oprot.writeI64(self.returnOrderId)
17364 
      oprot.writeFieldEnd()
17365 
    oprot.writeFieldStop()
17366 
    oprot.writeStructEnd()
17367 
 
3431 rajveer 17368 
  def validate(self):
17369 
    return
17370 
 
17371 
 
2690 chandransh 17372 
  def __repr__(self):
17373 
    L = ['%s=%r' % (key, value)
17374 
      for key, value in self.__dict__.iteritems()]
17375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17376 
 
17377 
  def __eq__(self, other):
17378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17379 
 
17380 
  def __ne__(self, other):
17381 
    return not (self == other)
17382 
 
17383 
class processReturn_result:
17384 
  """
17385 
  Attributes:
17386 
   - ex
17387 
  """
17388 
 
17389 
  thrift_spec = (
17390 
    None, # 0
17391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17392 
  )
17393 
 
17394 
  def __init__(self, ex=None,):
17395 
    self.ex = ex
17396 
 
17397 
  def read(self, iprot):
17398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17400 
      return
17401 
    iprot.readStructBegin()
17402 
    while True:
17403 
      (fname, ftype, fid) = iprot.readFieldBegin()
17404 
      if ftype == TType.STOP:
17405 
        break
17406 
      if fid == 1:
17407 
        if ftype == TType.STRUCT:
17408 
          self.ex = TransactionServiceException()
17409 
          self.ex.read(iprot)
17410 
        else:
17411 
          iprot.skip(ftype)
17412 
      else:
17413 
        iprot.skip(ftype)
17414 
      iprot.readFieldEnd()
17415 
    iprot.readStructEnd()
17416 
 
17417 
  def write(self, oprot):
17418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17420 
      return
17421 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17422 
    if self.ex is not None:
2690 chandransh 17423 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17424 
      self.ex.write(oprot)
17425 
      oprot.writeFieldEnd()
17426 
    oprot.writeFieldStop()
17427 
    oprot.writeStructEnd()
17428 
 
3431 rajveer 17429 
  def validate(self):
17430 
    return
17431 
 
17432 
 
2690 chandransh 17433 
  def __repr__(self):
17434 
    L = ['%s=%r' % (key, value)
17435 
      for key, value in self.__dict__.iteritems()]
17436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17437 
 
17438 
  def __eq__(self, other):
17439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17440 
 
17441 
  def __ne__(self, other):
17442 
    return not (self == other)
17443 
 
3451 chandransh 17444 
class updateWeight_args:
17445 
  """
17446 
  Attributes:
17447 
   - orderId
17448 
   - weight
17449 
  """
17450 
 
17451 
  thrift_spec = (
17452 
    None, # 0
17453 
    (1, TType.I64, 'orderId', None, None, ), # 1
17454 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17455 
  )
17456 
 
17457 
  def __init__(self, orderId=None, weight=None,):
17458 
    self.orderId = orderId
17459 
    self.weight = weight
17460 
 
17461 
  def read(self, iprot):
17462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17464 
      return
17465 
    iprot.readStructBegin()
17466 
    while True:
17467 
      (fname, ftype, fid) = iprot.readFieldBegin()
17468 
      if ftype == TType.STOP:
17469 
        break
17470 
      if fid == 1:
17471 
        if ftype == TType.I64:
17472 
          self.orderId = iprot.readI64();
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      elif fid == 2:
17476 
        if ftype == TType.DOUBLE:
17477 
          self.weight = iprot.readDouble();
17478 
        else:
17479 
          iprot.skip(ftype)
17480 
      else:
17481 
        iprot.skip(ftype)
17482 
      iprot.readFieldEnd()
17483 
    iprot.readStructEnd()
17484 
 
17485 
  def write(self, oprot):
17486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17488 
      return
17489 
    oprot.writeStructBegin('updateWeight_args')
17490 
    if self.orderId is not None:
17491 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17492 
      oprot.writeI64(self.orderId)
17493 
      oprot.writeFieldEnd()
17494 
    if self.weight is not None:
17495 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17496 
      oprot.writeDouble(self.weight)
17497 
      oprot.writeFieldEnd()
17498 
    oprot.writeFieldStop()
17499 
    oprot.writeStructEnd()
17500 
 
17501 
  def validate(self):
17502 
    return
17503 
 
17504 
 
17505 
  def __repr__(self):
17506 
    L = ['%s=%r' % (key, value)
17507 
      for key, value in self.__dict__.iteritems()]
17508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17509 
 
17510 
  def __eq__(self, other):
17511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17512 
 
17513 
  def __ne__(self, other):
17514 
    return not (self == other)
17515 
 
17516 
class updateWeight_result:
17517 
  """
17518 
  Attributes:
17519 
   - success
17520 
   - ex
17521 
  """
17522 
 
17523 
  thrift_spec = (
17524 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17525 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17526 
  )
17527 
 
17528 
  def __init__(self, success=None, ex=None,):
17529 
    self.success = success
17530 
    self.ex = ex
17531 
 
17532 
  def read(self, iprot):
17533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17535 
      return
17536 
    iprot.readStructBegin()
17537 
    while True:
17538 
      (fname, ftype, fid) = iprot.readFieldBegin()
17539 
      if ftype == TType.STOP:
17540 
        break
17541 
      if fid == 0:
17542 
        if ftype == TType.STRUCT:
17543 
          self.success = Order()
17544 
          self.success.read(iprot)
17545 
        else:
17546 
          iprot.skip(ftype)
17547 
      elif fid == 1:
17548 
        if ftype == TType.STRUCT:
17549 
          self.ex = TransactionServiceException()
17550 
          self.ex.read(iprot)
17551 
        else:
17552 
          iprot.skip(ftype)
17553 
      else:
17554 
        iprot.skip(ftype)
17555 
      iprot.readFieldEnd()
17556 
    iprot.readStructEnd()
17557 
 
17558 
  def write(self, oprot):
17559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17561 
      return
17562 
    oprot.writeStructBegin('updateWeight_result')
17563 
    if self.success is not None:
17564 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17565 
      self.success.write(oprot)
17566 
      oprot.writeFieldEnd()
17567 
    if self.ex is not None:
17568 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17569 
      self.ex.write(oprot)
17570 
      oprot.writeFieldEnd()
17571 
    oprot.writeFieldStop()
17572 
    oprot.writeStructEnd()
17573 
 
17574 
  def validate(self):
17575 
    return
17576 
 
17577 
 
17578 
  def __repr__(self):
17579 
    L = ['%s=%r' % (key, value)
17580 
      for key, value in self.__dict__.iteritems()]
17581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17582 
 
17583 
  def __eq__(self, other):
17584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17585 
 
17586 
  def __ne__(self, other):
17587 
    return not (self == other)
3469 chandransh 17588 
 
17589 
class changeItem_args:
17590 
  """
17591 
  Attributes:
17592 
   - orderId
17593 
   - itemId
17594 
  """
17595 
 
17596 
  thrift_spec = (
17597 
    None, # 0
17598 
    (1, TType.I64, 'orderId', None, None, ), # 1
17599 
    (2, TType.I64, 'itemId', None, None, ), # 2
17600 
  )
17601 
 
17602 
  def __init__(self, orderId=None, itemId=None,):
17603 
    self.orderId = orderId
17604 
    self.itemId = itemId
17605 
 
17606 
  def read(self, iprot):
17607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17609 
      return
17610 
    iprot.readStructBegin()
17611 
    while True:
17612 
      (fname, ftype, fid) = iprot.readFieldBegin()
17613 
      if ftype == TType.STOP:
17614 
        break
17615 
      if fid == 1:
17616 
        if ftype == TType.I64:
17617 
          self.orderId = iprot.readI64();
17618 
        else:
17619 
          iprot.skip(ftype)
17620 
      elif fid == 2:
17621 
        if ftype == TType.I64:
17622 
          self.itemId = iprot.readI64();
17623 
        else:
17624 
          iprot.skip(ftype)
17625 
      else:
17626 
        iprot.skip(ftype)
17627 
      iprot.readFieldEnd()
17628 
    iprot.readStructEnd()
17629 
 
17630 
  def write(self, oprot):
17631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17633 
      return
17634 
    oprot.writeStructBegin('changeItem_args')
17635 
    if self.orderId is not None:
17636 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17637 
      oprot.writeI64(self.orderId)
17638 
      oprot.writeFieldEnd()
17639 
    if self.itemId is not None:
17640 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17641 
      oprot.writeI64(self.itemId)
17642 
      oprot.writeFieldEnd()
17643 
    oprot.writeFieldStop()
17644 
    oprot.writeStructEnd()
17645 
 
17646 
  def validate(self):
17647 
    return
17648 
 
17649 
 
17650 
  def __repr__(self):
17651 
    L = ['%s=%r' % (key, value)
17652 
      for key, value in self.__dict__.iteritems()]
17653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17654 
 
17655 
  def __eq__(self, other):
17656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17657 
 
17658 
  def __ne__(self, other):
17659 
    return not (self == other)
17660 
 
17661 
class changeItem_result:
17662 
  """
17663 
  Attributes:
17664 
   - success
17665 
   - ex
17666 
  """
17667 
 
17668 
  thrift_spec = (
17669 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17671 
  )
17672 
 
17673 
  def __init__(self, success=None, ex=None,):
17674 
    self.success = success
17675 
    self.ex = ex
17676 
 
17677 
  def read(self, iprot):
17678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17680 
      return
17681 
    iprot.readStructBegin()
17682 
    while True:
17683 
      (fname, ftype, fid) = iprot.readFieldBegin()
17684 
      if ftype == TType.STOP:
17685 
        break
17686 
      if fid == 0:
17687 
        if ftype == TType.STRUCT:
17688 
          self.success = Order()
17689 
          self.success.read(iprot)
17690 
        else:
17691 
          iprot.skip(ftype)
17692 
      elif fid == 1:
17693 
        if ftype == TType.STRUCT:
17694 
          self.ex = TransactionServiceException()
17695 
          self.ex.read(iprot)
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      else:
17699 
        iprot.skip(ftype)
17700 
      iprot.readFieldEnd()
17701 
    iprot.readStructEnd()
17702 
 
17703 
  def write(self, oprot):
17704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17706 
      return
17707 
    oprot.writeStructBegin('changeItem_result')
17708 
    if self.success is not None:
17709 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17710 
      self.success.write(oprot)
17711 
      oprot.writeFieldEnd()
17712 
    if self.ex is not None:
17713 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17714 
      self.ex.write(oprot)
17715 
      oprot.writeFieldEnd()
17716 
    oprot.writeFieldStop()
17717 
    oprot.writeStructEnd()
17718 
 
17719 
  def validate(self):
17720 
    return
17721 
 
17722 
 
17723 
  def __repr__(self):
17724 
    L = ['%s=%r' % (key, value)
17725 
      for key, value in self.__dict__.iteritems()]
17726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17727 
 
17728 
  def __eq__(self, other):
17729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17730 
 
17731 
  def __ne__(self, other):
17732 
    return not (self == other)
17733 
 
17734 
class shiftToWarehouse_args:
17735 
  """
17736 
  Attributes:
17737 
   - orderId
17738 
   - warehouseId
17739 
  """
17740 
 
17741 
  thrift_spec = (
17742 
    None, # 0
17743 
    (1, TType.I64, 'orderId', None, None, ), # 1
17744 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17745 
  )
17746 
 
17747 
  def __init__(self, orderId=None, warehouseId=None,):
17748 
    self.orderId = orderId
17749 
    self.warehouseId = warehouseId
17750 
 
17751 
  def read(self, iprot):
17752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17754 
      return
17755 
    iprot.readStructBegin()
17756 
    while True:
17757 
      (fname, ftype, fid) = iprot.readFieldBegin()
17758 
      if ftype == TType.STOP:
17759 
        break
17760 
      if fid == 1:
17761 
        if ftype == TType.I64:
17762 
          self.orderId = iprot.readI64();
17763 
        else:
17764 
          iprot.skip(ftype)
17765 
      elif fid == 2:
17766 
        if ftype == TType.I64:
17767 
          self.warehouseId = iprot.readI64();
17768 
        else:
17769 
          iprot.skip(ftype)
17770 
      else:
17771 
        iprot.skip(ftype)
17772 
      iprot.readFieldEnd()
17773 
    iprot.readStructEnd()
17774 
 
17775 
  def write(self, oprot):
17776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17778 
      return
17779 
    oprot.writeStructBegin('shiftToWarehouse_args')
17780 
    if self.orderId is not None:
17781 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17782 
      oprot.writeI64(self.orderId)
17783 
      oprot.writeFieldEnd()
17784 
    if self.warehouseId is not None:
17785 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17786 
      oprot.writeI64(self.warehouseId)
17787 
      oprot.writeFieldEnd()
17788 
    oprot.writeFieldStop()
17789 
    oprot.writeStructEnd()
17790 
 
17791 
  def validate(self):
17792 
    return
17793 
 
17794 
 
17795 
  def __repr__(self):
17796 
    L = ['%s=%r' % (key, value)
17797 
      for key, value in self.__dict__.iteritems()]
17798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17799 
 
17800 
  def __eq__(self, other):
17801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17802 
 
17803 
  def __ne__(self, other):
17804 
    return not (self == other)
17805 
 
17806 
class shiftToWarehouse_result:
17807 
  """
17808 
  Attributes:
17809 
   - success
17810 
   - ex
17811 
  """
17812 
 
17813 
  thrift_spec = (
17814 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17816 
  )
17817 
 
17818 
  def __init__(self, success=None, ex=None,):
17819 
    self.success = success
17820 
    self.ex = ex
17821 
 
17822 
  def read(self, iprot):
17823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17825 
      return
17826 
    iprot.readStructBegin()
17827 
    while True:
17828 
      (fname, ftype, fid) = iprot.readFieldBegin()
17829 
      if ftype == TType.STOP:
17830 
        break
17831 
      if fid == 0:
17832 
        if ftype == TType.STRUCT:
17833 
          self.success = Order()
17834 
          self.success.read(iprot)
17835 
        else:
17836 
          iprot.skip(ftype)
17837 
      elif fid == 1:
17838 
        if ftype == TType.STRUCT:
17839 
          self.ex = TransactionServiceException()
17840 
          self.ex.read(iprot)
17841 
        else:
17842 
          iprot.skip(ftype)
17843 
      else:
17844 
        iprot.skip(ftype)
17845 
      iprot.readFieldEnd()
17846 
    iprot.readStructEnd()
17847 
 
17848 
  def write(self, oprot):
17849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17851 
      return
17852 
    oprot.writeStructBegin('shiftToWarehouse_result')
17853 
    if self.success is not None:
17854 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17855 
      self.success.write(oprot)
17856 
      oprot.writeFieldEnd()
17857 
    if self.ex is not None:
17858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17859 
      self.ex.write(oprot)
17860 
      oprot.writeFieldEnd()
17861 
    oprot.writeFieldStop()
17862 
    oprot.writeStructEnd()
17863 
 
17864 
  def validate(self):
17865 
    return
17866 
 
17867 
 
17868 
  def __repr__(self):
17869 
    L = ['%s=%r' % (key, value)
17870 
      for key, value in self.__dict__.iteritems()]
17871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17872 
 
17873 
  def __eq__(self, other):
17874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17875 
 
17876 
  def __ne__(self, other):
17877 
    return not (self == other)
3553 chandransh 17878 
 
17879 
class addDelayReason_args:
17880 
  """
17881 
  Attributes:
17882 
   - orderId
17883 
   - delayReason
3986 chandransh 17884 
   - furtherDelay
4647 rajveer 17885 
   - delayReasonText
3553 chandransh 17886 
  """
17887 
 
17888 
  thrift_spec = (
17889 
    None, # 0
17890 
    (1, TType.I64, 'orderId', None, None, ), # 1
17891 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17892 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17893 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17894 
  )
17895 
 
4647 rajveer 17896 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17897 
    self.orderId = orderId
17898 
    self.delayReason = delayReason
3986 chandransh 17899 
    self.furtherDelay = furtherDelay
4647 rajveer 17900 
    self.delayReasonText = delayReasonText
3553 chandransh 17901 
 
17902 
  def read(self, iprot):
17903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17905 
      return
17906 
    iprot.readStructBegin()
17907 
    while True:
17908 
      (fname, ftype, fid) = iprot.readFieldBegin()
17909 
      if ftype == TType.STOP:
17910 
        break
17911 
      if fid == 1:
17912 
        if ftype == TType.I64:
17913 
          self.orderId = iprot.readI64();
17914 
        else:
17915 
          iprot.skip(ftype)
17916 
      elif fid == 2:
17917 
        if ftype == TType.I32:
17918 
          self.delayReason = iprot.readI32();
17919 
        else:
17920 
          iprot.skip(ftype)
3986 chandransh 17921 
      elif fid == 3:
17922 
        if ftype == TType.I64:
17923 
          self.furtherDelay = iprot.readI64();
17924 
        else:
17925 
          iprot.skip(ftype)
4647 rajveer 17926 
      elif fid == 4:
17927 
        if ftype == TType.STRING:
17928 
          self.delayReasonText = iprot.readString();
17929 
        else:
17930 
          iprot.skip(ftype)
3553 chandransh 17931 
      else:
17932 
        iprot.skip(ftype)
17933 
      iprot.readFieldEnd()
17934 
    iprot.readStructEnd()
17935 
 
17936 
  def write(self, oprot):
17937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17939 
      return
17940 
    oprot.writeStructBegin('addDelayReason_args')
17941 
    if self.orderId is not None:
17942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17943 
      oprot.writeI64(self.orderId)
17944 
      oprot.writeFieldEnd()
17945 
    if self.delayReason is not None:
17946 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17947 
      oprot.writeI32(self.delayReason)
17948 
      oprot.writeFieldEnd()
3986 chandransh 17949 
    if self.furtherDelay is not None:
17950 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17951 
      oprot.writeI64(self.furtherDelay)
17952 
      oprot.writeFieldEnd()
4647 rajveer 17953 
    if self.delayReasonText is not None:
17954 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17955 
      oprot.writeString(self.delayReasonText)
17956 
      oprot.writeFieldEnd()
3553 chandransh 17957 
    oprot.writeFieldStop()
17958 
    oprot.writeStructEnd()
17959 
 
17960 
  def validate(self):
17961 
    return
17962 
 
17963 
 
17964 
  def __repr__(self):
17965 
    L = ['%s=%r' % (key, value)
17966 
      for key, value in self.__dict__.iteritems()]
17967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17968 
 
17969 
  def __eq__(self, other):
17970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17971 
 
17972 
  def __ne__(self, other):
17973 
    return not (self == other)
17974 
 
17975 
class addDelayReason_result:
17976 
  """
17977 
  Attributes:
17978 
   - success
17979 
   - ex
17980 
  """
17981 
 
17982 
  thrift_spec = (
17983 
    (0, TType.BOOL, 'success', None, None, ), # 0
17984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17985 
  )
17986 
 
17987 
  def __init__(self, success=None, ex=None,):
17988 
    self.success = success
17989 
    self.ex = ex
17990 
 
17991 
  def read(self, iprot):
17992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17994 
      return
17995 
    iprot.readStructBegin()
17996 
    while True:
17997 
      (fname, ftype, fid) = iprot.readFieldBegin()
17998 
      if ftype == TType.STOP:
17999 
        break
18000 
      if fid == 0:
18001 
        if ftype == TType.BOOL:
18002 
          self.success = iprot.readBool();
18003 
        else:
18004 
          iprot.skip(ftype)
18005 
      elif fid == 1:
18006 
        if ftype == TType.STRUCT:
18007 
          self.ex = TransactionServiceException()
18008 
          self.ex.read(iprot)
18009 
        else:
18010 
          iprot.skip(ftype)
18011 
      else:
18012 
        iprot.skip(ftype)
18013 
      iprot.readFieldEnd()
18014 
    iprot.readStructEnd()
18015 
 
18016 
  def write(self, oprot):
18017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18019 
      return
18020 
    oprot.writeStructBegin('addDelayReason_result')
18021 
    if self.success is not None:
18022 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18023 
      oprot.writeBool(self.success)
18024 
      oprot.writeFieldEnd()
18025 
    if self.ex is not None:
18026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18027 
      self.ex.write(oprot)
18028 
      oprot.writeFieldEnd()
18029 
    oprot.writeFieldStop()
18030 
    oprot.writeStructEnd()
18031 
 
18032 
  def validate(self):
18033 
    return
18034 
 
18035 
 
18036 
  def __repr__(self):
18037 
    L = ['%s=%r' % (key, value)
18038 
      for key, value in self.__dict__.iteritems()]
18039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18040 
 
18041 
  def __eq__(self, other):
18042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18043 
 
18044 
  def __ne__(self, other):
18045 
    return not (self == other)
3956 chandransh 18046 
 
18047 
class reconcileCodCollection_args:
18048 
  """
18049 
  Attributes:
18050 
   - collectedAmountMap
18051 
   - xferBy
18052 
   - xferTxnId
18053 
   - xferDate
18054 
  """
18055 
 
18056 
  thrift_spec = (
18057 
    None, # 0
18058 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18059 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18060 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18061 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18062 
  )
18063 
 
18064 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18065 
    self.collectedAmountMap = collectedAmountMap
18066 
    self.xferBy = xferBy
18067 
    self.xferTxnId = xferTxnId
18068 
    self.xferDate = xferDate
18069 
 
18070 
  def read(self, iprot):
18071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18073 
      return
18074 
    iprot.readStructBegin()
18075 
    while True:
18076 
      (fname, ftype, fid) = iprot.readFieldBegin()
18077 
      if ftype == TType.STOP:
18078 
        break
18079 
      if fid == 1:
18080 
        if ftype == TType.MAP:
18081 
          self.collectedAmountMap = {}
5481 phani.kuma 18082 
          (_ktype397, _vtype398, _size396 ) = iprot.readMapBegin()
18083 
          for _i400 in xrange(_size396):
18084 
            _key401 = iprot.readString();
18085 
            _val402 = iprot.readDouble();
18086 
            self.collectedAmountMap[_key401] = _val402
3956 chandransh 18087 
          iprot.readMapEnd()
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      elif fid == 2:
18091 
        if ftype == TType.STRING:
18092 
          self.xferBy = iprot.readString();
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      elif fid == 3:
18096 
        if ftype == TType.STRING:
18097 
          self.xferTxnId = iprot.readString();
18098 
        else:
18099 
          iprot.skip(ftype)
18100 
      elif fid == 4:
18101 
        if ftype == TType.I64:
18102 
          self.xferDate = iprot.readI64();
18103 
        else:
18104 
          iprot.skip(ftype)
18105 
      else:
18106 
        iprot.skip(ftype)
18107 
      iprot.readFieldEnd()
18108 
    iprot.readStructEnd()
18109 
 
18110 
  def write(self, oprot):
18111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18113 
      return
18114 
    oprot.writeStructBegin('reconcileCodCollection_args')
18115 
    if self.collectedAmountMap is not None:
18116 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18117 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5481 phani.kuma 18118 
      for kiter403,viter404 in self.collectedAmountMap.items():
18119 
        oprot.writeString(kiter403)
18120 
        oprot.writeDouble(viter404)
3956 chandransh 18121 
      oprot.writeMapEnd()
18122 
      oprot.writeFieldEnd()
18123 
    if self.xferBy is not None:
18124 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18125 
      oprot.writeString(self.xferBy)
18126 
      oprot.writeFieldEnd()
18127 
    if self.xferTxnId is not None:
18128 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18129 
      oprot.writeString(self.xferTxnId)
18130 
      oprot.writeFieldEnd()
18131 
    if self.xferDate is not None:
18132 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18133 
      oprot.writeI64(self.xferDate)
18134 
      oprot.writeFieldEnd()
18135 
    oprot.writeFieldStop()
18136 
    oprot.writeStructEnd()
18137 
 
18138 
  def validate(self):
18139 
    return
18140 
 
18141 
 
18142 
  def __repr__(self):
18143 
    L = ['%s=%r' % (key, value)
18144 
      for key, value in self.__dict__.iteritems()]
18145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18146 
 
18147 
  def __eq__(self, other):
18148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18149 
 
18150 
  def __ne__(self, other):
18151 
    return not (self == other)
18152 
 
18153 
class reconcileCodCollection_result:
18154 
  """
18155 
  Attributes:
18156 
   - success
18157 
   - ex
18158 
  """
18159 
 
18160 
  thrift_spec = (
18161 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18163 
  )
18164 
 
18165 
  def __init__(self, success=None, ex=None,):
18166 
    self.success = success
18167 
    self.ex = ex
18168 
 
18169 
  def read(self, iprot):
18170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18172 
      return
18173 
    iprot.readStructBegin()
18174 
    while True:
18175 
      (fname, ftype, fid) = iprot.readFieldBegin()
18176 
      if ftype == TType.STOP:
18177 
        break
18178 
      if fid == 0:
18179 
        if ftype == TType.MAP:
18180 
          self.success = {}
5481 phani.kuma 18181 
          (_ktype406, _vtype407, _size405 ) = iprot.readMapBegin()
18182 
          for _i409 in xrange(_size405):
18183 
            _key410 = iprot.readString();
18184 
            _val411 = iprot.readString();
18185 
            self.success[_key410] = _val411
3956 chandransh 18186 
          iprot.readMapEnd()
18187 
        else:
18188 
          iprot.skip(ftype)
18189 
      elif fid == 1:
18190 
        if ftype == TType.STRUCT:
18191 
          self.ex = TransactionServiceException()
18192 
          self.ex.read(iprot)
18193 
        else:
18194 
          iprot.skip(ftype)
18195 
      else:
18196 
        iprot.skip(ftype)
18197 
      iprot.readFieldEnd()
18198 
    iprot.readStructEnd()
18199 
 
18200 
  def write(self, oprot):
18201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18203 
      return
18204 
    oprot.writeStructBegin('reconcileCodCollection_result')
18205 
    if self.success is not None:
18206 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18207 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5481 phani.kuma 18208 
      for kiter412,viter413 in self.success.items():
18209 
        oprot.writeString(kiter412)
18210 
        oprot.writeString(viter413)
3956 chandransh 18211 
      oprot.writeMapEnd()
18212 
      oprot.writeFieldEnd()
18213 
    if self.ex is not None:
18214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18215 
      self.ex.write(oprot)
18216 
      oprot.writeFieldEnd()
18217 
    oprot.writeFieldStop()
18218 
    oprot.writeStructEnd()
18219 
 
18220 
  def validate(self):
18221 
    return
18222 
 
18223 
 
18224 
  def __repr__(self):
18225 
    L = ['%s=%r' % (key, value)
18226 
      for key, value in self.__dict__.iteritems()]
18227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18228 
 
18229 
  def __eq__(self, other):
18230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18231 
 
18232 
  def __ne__(self, other):
18233 
    return not (self == other)
4008 mandeep.dh 18234 
 
18235 
class getTransactionsRequiringExtraProcessing_args:
18236 
  """
18237 
  Attributes:
18238 
   - category
18239 
  """
18240 
 
18241 
  thrift_spec = (
18242 
    None, # 0
18243 
    (1, TType.I32, 'category', None, None, ), # 1
18244 
  )
18245 
 
18246 
  def __init__(self, category=None,):
18247 
    self.category = category
18248 
 
18249 
  def read(self, iprot):
18250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18252 
      return
18253 
    iprot.readStructBegin()
18254 
    while True:
18255 
      (fname, ftype, fid) = iprot.readFieldBegin()
18256 
      if ftype == TType.STOP:
18257 
        break
18258 
      if fid == 1:
18259 
        if ftype == TType.I32:
18260 
          self.category = iprot.readI32();
18261 
        else:
18262 
          iprot.skip(ftype)
18263 
      else:
18264 
        iprot.skip(ftype)
18265 
      iprot.readFieldEnd()
18266 
    iprot.readStructEnd()
18267 
 
18268 
  def write(self, oprot):
18269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18271 
      return
18272 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18273 
    if self.category is not None:
18274 
      oprot.writeFieldBegin('category', TType.I32, 1)
18275 
      oprot.writeI32(self.category)
18276 
      oprot.writeFieldEnd()
18277 
    oprot.writeFieldStop()
18278 
    oprot.writeStructEnd()
18279 
 
18280 
  def validate(self):
18281 
    return
18282 
 
18283 
 
18284 
  def __repr__(self):
18285 
    L = ['%s=%r' % (key, value)
18286 
      for key, value in self.__dict__.iteritems()]
18287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18288 
 
18289 
  def __eq__(self, other):
18290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18291 
 
18292 
  def __ne__(self, other):
18293 
    return not (self == other)
18294 
 
18295 
class getTransactionsRequiringExtraProcessing_result:
18296 
  """
18297 
  Attributes:
18298 
   - success
18299 
  """
18300 
 
18301 
  thrift_spec = (
18302 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18303 
  )
18304 
 
18305 
  def __init__(self, success=None,):
18306 
    self.success = success
18307 
 
18308 
  def read(self, iprot):
18309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18311 
      return
18312 
    iprot.readStructBegin()
18313 
    while True:
18314 
      (fname, ftype, fid) = iprot.readFieldBegin()
18315 
      if ftype == TType.STOP:
18316 
        break
18317 
      if fid == 0:
18318 
        if ftype == TType.LIST:
18319 
          self.success = []
5481 phani.kuma 18320 
          (_etype417, _size414) = iprot.readListBegin()
18321 
          for _i418 in xrange(_size414):
18322 
            _elem419 = iprot.readI64();
18323 
            self.success.append(_elem419)
4008 mandeep.dh 18324 
          iprot.readListEnd()
18325 
        else:
18326 
          iprot.skip(ftype)
18327 
      else:
18328 
        iprot.skip(ftype)
18329 
      iprot.readFieldEnd()
18330 
    iprot.readStructEnd()
18331 
 
18332 
  def write(self, oprot):
18333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18335 
      return
18336 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18337 
    if self.success is not None:
18338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18339 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 18340 
      for iter420 in self.success:
18341 
        oprot.writeI64(iter420)
4008 mandeep.dh 18342 
      oprot.writeListEnd()
18343 
      oprot.writeFieldEnd()
18344 
    oprot.writeFieldStop()
18345 
    oprot.writeStructEnd()
18346 
 
18347 
  def validate(self):
18348 
    return
18349 
 
18350 
 
18351 
  def __repr__(self):
18352 
    L = ['%s=%r' % (key, value)
18353 
      for key, value in self.__dict__.iteritems()]
18354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18355 
 
18356 
  def __eq__(self, other):
18357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18358 
 
18359 
  def __ne__(self, other):
18360 
    return not (self == other)
18361 
 
18362 
class markTransactionAsProcessed_args:
18363 
  """
18364 
  Attributes:
18365 
   - transactionId
18366 
   - category
18367 
  """
18368 
 
18369 
  thrift_spec = (
18370 
    None, # 0
18371 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18372 
    (2, TType.I32, 'category', None, None, ), # 2
18373 
  )
18374 
 
18375 
  def __init__(self, transactionId=None, category=None,):
18376 
    self.transactionId = transactionId
18377 
    self.category = category
18378 
 
18379 
  def read(self, iprot):
18380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18382 
      return
18383 
    iprot.readStructBegin()
18384 
    while True:
18385 
      (fname, ftype, fid) = iprot.readFieldBegin()
18386 
      if ftype == TType.STOP:
18387 
        break
18388 
      if fid == 1:
18389 
        if ftype == TType.I64:
18390 
          self.transactionId = iprot.readI64();
18391 
        else:
18392 
          iprot.skip(ftype)
18393 
      elif fid == 2:
18394 
        if ftype == TType.I32:
18395 
          self.category = iprot.readI32();
18396 
        else:
18397 
          iprot.skip(ftype)
18398 
      else:
18399 
        iprot.skip(ftype)
18400 
      iprot.readFieldEnd()
18401 
    iprot.readStructEnd()
18402 
 
18403 
  def write(self, oprot):
18404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18406 
      return
18407 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18408 
    if self.transactionId is not None:
18409 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18410 
      oprot.writeI64(self.transactionId)
18411 
      oprot.writeFieldEnd()
18412 
    if self.category is not None:
18413 
      oprot.writeFieldBegin('category', TType.I32, 2)
18414 
      oprot.writeI32(self.category)
18415 
      oprot.writeFieldEnd()
18416 
    oprot.writeFieldStop()
18417 
    oprot.writeStructEnd()
18418 
 
18419 
  def validate(self):
18420 
    return
18421 
 
18422 
 
18423 
  def __repr__(self):
18424 
    L = ['%s=%r' % (key, value)
18425 
      for key, value in self.__dict__.iteritems()]
18426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18427 
 
18428 
  def __eq__(self, other):
18429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18430 
 
18431 
  def __ne__(self, other):
18432 
    return not (self == other)
18433 
 
18434 
class markTransactionAsProcessed_result:
18435 
 
18436 
  thrift_spec = (
18437 
  )
18438 
 
18439 
  def read(self, iprot):
18440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18442 
      return
18443 
    iprot.readStructBegin()
18444 
    while True:
18445 
      (fname, ftype, fid) = iprot.readFieldBegin()
18446 
      if ftype == TType.STOP:
18447 
        break
18448 
      else:
18449 
        iprot.skip(ftype)
18450 
      iprot.readFieldEnd()
18451 
    iprot.readStructEnd()
18452 
 
18453 
  def write(self, oprot):
18454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18456 
      return
18457 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18458 
    oprot.writeFieldStop()
18459 
    oprot.writeStructEnd()
18460 
 
18461 
  def validate(self):
18462 
    return
18463 
 
18464 
 
18465 
  def __repr__(self):
18466 
    L = ['%s=%r' % (key, value)
18467 
      for key, value in self.__dict__.iteritems()]
18468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18469 
 
18470 
  def __eq__(self, other):
18471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18472 
 
18473 
  def __ne__(self, other):
18474 
    return not (self == other)
4018 chandransh 18475 
 
18476 
class getItemWiseRiskyOrdersCount_args:
18477 
 
18478 
  thrift_spec = (
18479 
  )
18480 
 
18481 
  def read(self, iprot):
18482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18484 
      return
18485 
    iprot.readStructBegin()
18486 
    while True:
18487 
      (fname, ftype, fid) = iprot.readFieldBegin()
18488 
      if ftype == TType.STOP:
18489 
        break
18490 
      else:
18491 
        iprot.skip(ftype)
18492 
      iprot.readFieldEnd()
18493 
    iprot.readStructEnd()
18494 
 
18495 
  def write(self, oprot):
18496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18498 
      return
18499 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18500 
    oprot.writeFieldStop()
18501 
    oprot.writeStructEnd()
18502 
 
18503 
  def validate(self):
18504 
    return
18505 
 
18506 
 
18507 
  def __repr__(self):
18508 
    L = ['%s=%r' % (key, value)
18509 
      for key, value in self.__dict__.iteritems()]
18510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18511 
 
18512 
  def __eq__(self, other):
18513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18514 
 
18515 
  def __ne__(self, other):
18516 
    return not (self == other)
18517 
 
18518 
class getItemWiseRiskyOrdersCount_result:
18519 
  """
18520 
  Attributes:
18521 
   - success
18522 
  """
18523 
 
18524 
  thrift_spec = (
18525 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18526 
  )
18527 
 
18528 
  def __init__(self, success=None,):
18529 
    self.success = success
18530 
 
18531 
  def read(self, iprot):
18532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18534 
      return
18535 
    iprot.readStructBegin()
18536 
    while True:
18537 
      (fname, ftype, fid) = iprot.readFieldBegin()
18538 
      if ftype == TType.STOP:
18539 
        break
18540 
      if fid == 0:
18541 
        if ftype == TType.MAP:
18542 
          self.success = {}
5481 phani.kuma 18543 
          (_ktype422, _vtype423, _size421 ) = iprot.readMapBegin()
18544 
          for _i425 in xrange(_size421):
18545 
            _key426 = iprot.readI64();
18546 
            _val427 = iprot.readI64();
18547 
            self.success[_key426] = _val427
4018 chandransh 18548 
          iprot.readMapEnd()
18549 
        else:
18550 
          iprot.skip(ftype)
18551 
      else:
18552 
        iprot.skip(ftype)
18553 
      iprot.readFieldEnd()
18554 
    iprot.readStructEnd()
18555 
 
18556 
  def write(self, oprot):
18557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18559 
      return
18560 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18561 
    if self.success is not None:
18562 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18563 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 18564 
      for kiter428,viter429 in self.success.items():
18565 
        oprot.writeI64(kiter428)
18566 
        oprot.writeI64(viter429)
4018 chandransh 18567 
      oprot.writeMapEnd()
18568 
      oprot.writeFieldEnd()
18569 
    oprot.writeFieldStop()
18570 
    oprot.writeStructEnd()
18571 
 
18572 
  def validate(self):
18573 
    return
18574 
 
18575 
 
18576 
  def __repr__(self):
18577 
    L = ['%s=%r' % (key, value)
18578 
      for key, value in self.__dict__.iteritems()]
18579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18580 
 
18581 
  def __eq__(self, other):
18582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18583 
 
18584 
  def __ne__(self, other):
18585 
    return not (self == other)
4247 rajveer 18586 
 
4295 varun.gupt 18587 
class getOrdersForItemIds_args:
18588 
  """
18589 
  Attributes:
18590 
   - itemIds
18591 
  """
18592 
 
18593 
  thrift_spec = (
18594 
    None, # 0
18595 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18596 
  )
18597 
 
18598 
  def __init__(self, itemIds=None,):
18599 
    self.itemIds = itemIds
18600 
 
18601 
  def read(self, iprot):
18602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18604 
      return
18605 
    iprot.readStructBegin()
18606 
    while True:
18607 
      (fname, ftype, fid) = iprot.readFieldBegin()
18608 
      if ftype == TType.STOP:
18609 
        break
18610 
      if fid == 1:
18611 
        if ftype == TType.LIST:
18612 
          self.itemIds = []
5481 phani.kuma 18613 
          (_etype433, _size430) = iprot.readListBegin()
18614 
          for _i434 in xrange(_size430):
18615 
            _elem435 = iprot.readI64();
18616 
            self.itemIds.append(_elem435)
4295 varun.gupt 18617 
          iprot.readListEnd()
18618 
        else:
18619 
          iprot.skip(ftype)
18620 
      else:
18621 
        iprot.skip(ftype)
18622 
      iprot.readFieldEnd()
18623 
    iprot.readStructEnd()
18624 
 
18625 
  def write(self, oprot):
18626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18628 
      return
18629 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18630 
    if self.itemIds is not None:
18631 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18632 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5481 phani.kuma 18633 
      for iter436 in self.itemIds:
18634 
        oprot.writeI64(iter436)
4295 varun.gupt 18635 
      oprot.writeListEnd()
18636 
      oprot.writeFieldEnd()
18637 
    oprot.writeFieldStop()
18638 
    oprot.writeStructEnd()
18639 
 
18640 
  def validate(self):
18641 
    return
18642 
 
18643 
 
18644 
  def __repr__(self):
18645 
    L = ['%s=%r' % (key, value)
18646 
      for key, value in self.__dict__.iteritems()]
18647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18648 
 
18649 
  def __eq__(self, other):
18650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18651 
 
18652 
  def __ne__(self, other):
18653 
    return not (self == other)
18654 
 
18655 
class getOrdersForItemIds_result:
18656 
  """
18657 
  Attributes:
18658 
   - success
18659 
  """
18660 
 
18661 
  thrift_spec = (
18662 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18663 
  )
18664 
 
18665 
  def __init__(self, success=None,):
18666 
    self.success = success
18667 
 
18668 
  def read(self, iprot):
18669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18671 
      return
18672 
    iprot.readStructBegin()
18673 
    while True:
18674 
      (fname, ftype, fid) = iprot.readFieldBegin()
18675 
      if ftype == TType.STOP:
18676 
        break
18677 
      if fid == 0:
18678 
        if ftype == TType.LIST:
18679 
          self.success = []
5481 phani.kuma 18680 
          (_etype440, _size437) = iprot.readListBegin()
18681 
          for _i441 in xrange(_size437):
18682 
            _elem442 = Order()
18683 
            _elem442.read(iprot)
18684 
            self.success.append(_elem442)
4295 varun.gupt 18685 
          iprot.readListEnd()
18686 
        else:
18687 
          iprot.skip(ftype)
18688 
      else:
18689 
        iprot.skip(ftype)
18690 
      iprot.readFieldEnd()
18691 
    iprot.readStructEnd()
18692 
 
18693 
  def write(self, oprot):
18694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18696 
      return
18697 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18698 
    if self.success is not None:
18699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 18701 
      for iter443 in self.success:
18702 
        iter443.write(oprot)
4295 varun.gupt 18703 
      oprot.writeListEnd()
18704 
      oprot.writeFieldEnd()
18705 
    oprot.writeFieldStop()
18706 
    oprot.writeStructEnd()
18707 
 
18708 
  def validate(self):
18709 
    return
18710 
 
18711 
 
18712 
  def __repr__(self):
18713 
    L = ['%s=%r' % (key, value)
18714 
      for key, value in self.__dict__.iteritems()]
18715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18716 
 
18717 
  def __eq__(self, other):
18718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18719 
 
18720 
  def __ne__(self, other):
18721 
    return not (self == other)
18722 
 
4247 rajveer 18723 
class markOrderCancellationRequestReceived_args:
18724 
  """
18725 
  Attributes:
18726 
   - orderId
18727 
  """
18728 
 
18729 
  thrift_spec = (
18730 
    None, # 0
18731 
    (1, TType.I64, 'orderId', None, None, ), # 1
18732 
  )
18733 
 
18734 
  def __init__(self, orderId=None,):
18735 
    self.orderId = orderId
18736 
 
18737 
  def read(self, iprot):
18738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18740 
      return
18741 
    iprot.readStructBegin()
18742 
    while True:
18743 
      (fname, ftype, fid) = iprot.readFieldBegin()
18744 
      if ftype == TType.STOP:
18745 
        break
18746 
      if fid == 1:
18747 
        if ftype == TType.I64:
18748 
          self.orderId = iprot.readI64();
18749 
        else:
18750 
          iprot.skip(ftype)
18751 
      else:
18752 
        iprot.skip(ftype)
18753 
      iprot.readFieldEnd()
18754 
    iprot.readStructEnd()
18755 
 
18756 
  def write(self, oprot):
18757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18759 
      return
18760 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18761 
    if self.orderId is not None:
18762 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18763 
      oprot.writeI64(self.orderId)
18764 
      oprot.writeFieldEnd()
18765 
    oprot.writeFieldStop()
18766 
    oprot.writeStructEnd()
18767 
 
18768 
  def validate(self):
18769 
    return
18770 
 
18771 
 
18772 
  def __repr__(self):
18773 
    L = ['%s=%r' % (key, value)
18774 
      for key, value in self.__dict__.iteritems()]
18775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18776 
 
18777 
  def __eq__(self, other):
18778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18779 
 
18780 
  def __ne__(self, other):
18781 
    return not (self == other)
18782 
 
18783 
class markOrderCancellationRequestReceived_result:
18784 
  """
18785 
  Attributes:
18786 
   - ex
18787 
  """
18788 
 
18789 
  thrift_spec = (
18790 
    None, # 0
18791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18792 
  )
18793 
 
18794 
  def __init__(self, ex=None,):
18795 
    self.ex = ex
18796 
 
18797 
  def read(self, iprot):
18798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18800 
      return
18801 
    iprot.readStructBegin()
18802 
    while True:
18803 
      (fname, ftype, fid) = iprot.readFieldBegin()
18804 
      if ftype == TType.STOP:
18805 
        break
18806 
      if fid == 1:
18807 
        if ftype == TType.STRUCT:
18808 
          self.ex = TransactionServiceException()
18809 
          self.ex.read(iprot)
18810 
        else:
18811 
          iprot.skip(ftype)
18812 
      else:
18813 
        iprot.skip(ftype)
18814 
      iprot.readFieldEnd()
18815 
    iprot.readStructEnd()
18816 
 
18817 
  def write(self, oprot):
18818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18820 
      return
18821 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18822 
    if self.ex is not None:
18823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18824 
      self.ex.write(oprot)
18825 
      oprot.writeFieldEnd()
18826 
    oprot.writeFieldStop()
18827 
    oprot.writeStructEnd()
18828 
 
18829 
  def validate(self):
18830 
    return
18831 
 
18832 
 
18833 
  def __repr__(self):
18834 
    L = ['%s=%r' % (key, value)
18835 
      for key, value in self.__dict__.iteritems()]
18836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18837 
 
18838 
  def __eq__(self, other):
18839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18840 
 
18841 
  def __ne__(self, other):
18842 
    return not (self == other)
18843 
 
18844 
class markOrderCancellationRequestConfirmed_args:
18845 
  """
18846 
  Attributes:
18847 
   - orderId
18848 
  """
18849 
 
18850 
  thrift_spec = (
18851 
    None, # 0
18852 
    (1, TType.I64, 'orderId', None, None, ), # 1
18853 
  )
18854 
 
18855 
  def __init__(self, orderId=None,):
18856 
    self.orderId = orderId
18857 
 
18858 
  def read(self, iprot):
18859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18861 
      return
18862 
    iprot.readStructBegin()
18863 
    while True:
18864 
      (fname, ftype, fid) = iprot.readFieldBegin()
18865 
      if ftype == TType.STOP:
18866 
        break
18867 
      if fid == 1:
18868 
        if ftype == TType.I64:
18869 
          self.orderId = iprot.readI64();
18870 
        else:
18871 
          iprot.skip(ftype)
18872 
      else:
18873 
        iprot.skip(ftype)
18874 
      iprot.readFieldEnd()
18875 
    iprot.readStructEnd()
18876 
 
18877 
  def write(self, oprot):
18878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18880 
      return
18881 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18882 
    if self.orderId is not None:
18883 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18884 
      oprot.writeI64(self.orderId)
18885 
      oprot.writeFieldEnd()
18886 
    oprot.writeFieldStop()
18887 
    oprot.writeStructEnd()
18888 
 
18889 
  def validate(self):
18890 
    return
18891 
 
18892 
 
18893 
  def __repr__(self):
18894 
    L = ['%s=%r' % (key, value)
18895 
      for key, value in self.__dict__.iteritems()]
18896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18897 
 
18898 
  def __eq__(self, other):
18899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18900 
 
18901 
  def __ne__(self, other):
18902 
    return not (self == other)
18903 
 
18904 
class markOrderCancellationRequestConfirmed_result:
18905 
  """
18906 
  Attributes:
18907 
   - ex
18908 
  """
18909 
 
18910 
  thrift_spec = (
18911 
    None, # 0
18912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18913 
  )
18914 
 
18915 
  def __init__(self, ex=None,):
18916 
    self.ex = ex
18917 
 
18918 
  def read(self, iprot):
18919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18921 
      return
18922 
    iprot.readStructBegin()
18923 
    while True:
18924 
      (fname, ftype, fid) = iprot.readFieldBegin()
18925 
      if ftype == TType.STOP:
18926 
        break
18927 
      if fid == 1:
18928 
        if ftype == TType.STRUCT:
18929 
          self.ex = TransactionServiceException()
18930 
          self.ex.read(iprot)
18931 
        else:
18932 
          iprot.skip(ftype)
18933 
      else:
18934 
        iprot.skip(ftype)
18935 
      iprot.readFieldEnd()
18936 
    iprot.readStructEnd()
18937 
 
18938 
  def write(self, oprot):
18939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18941 
      return
18942 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18943 
    if self.ex is not None:
18944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18945 
      self.ex.write(oprot)
18946 
      oprot.writeFieldEnd()
18947 
    oprot.writeFieldStop()
18948 
    oprot.writeStructEnd()
18949 
 
18950 
  def validate(self):
18951 
    return
18952 
 
18953 
 
18954 
  def __repr__(self):
18955 
    L = ['%s=%r' % (key, value)
18956 
      for key, value in self.__dict__.iteritems()]
18957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18958 
 
18959 
  def __eq__(self, other):
18960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18961 
 
18962 
  def __ne__(self, other):
18963 
    return not (self == other)
18964 
 
18965 
class markOrderCancellationRequestDenied_args:
18966 
  """
18967 
  Attributes:
18968 
   - orderId
18969 
  """
18970 
 
18971 
  thrift_spec = (
18972 
    None, # 0
18973 
    (1, TType.I64, 'orderId', None, None, ), # 1
18974 
  )
18975 
 
18976 
  def __init__(self, orderId=None,):
18977 
    self.orderId = orderId
18978 
 
18979 
  def read(self, iprot):
18980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18982 
      return
18983 
    iprot.readStructBegin()
18984 
    while True:
18985 
      (fname, ftype, fid) = iprot.readFieldBegin()
18986 
      if ftype == TType.STOP:
18987 
        break
18988 
      if fid == 1:
18989 
        if ftype == TType.I64:
18990 
          self.orderId = iprot.readI64();
18991 
        else:
18992 
          iprot.skip(ftype)
18993 
      else:
18994 
        iprot.skip(ftype)
18995 
      iprot.readFieldEnd()
18996 
    iprot.readStructEnd()
18997 
 
18998 
  def write(self, oprot):
18999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19001 
      return
19002 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19003 
    if self.orderId is not None:
19004 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19005 
      oprot.writeI64(self.orderId)
19006 
      oprot.writeFieldEnd()
19007 
    oprot.writeFieldStop()
19008 
    oprot.writeStructEnd()
19009 
 
19010 
  def validate(self):
19011 
    return
19012 
 
19013 
 
19014 
  def __repr__(self):
19015 
    L = ['%s=%r' % (key, value)
19016 
      for key, value in self.__dict__.iteritems()]
19017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19018 
 
19019 
  def __eq__(self, other):
19020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19021 
 
19022 
  def __ne__(self, other):
19023 
    return not (self == other)
19024 
 
19025 
class markOrderCancellationRequestDenied_result:
19026 
  """
19027 
  Attributes:
19028 
   - ex
19029 
  """
19030 
 
19031 
  thrift_spec = (
19032 
    None, # 0
19033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19034 
  )
19035 
 
19036 
  def __init__(self, ex=None,):
19037 
    self.ex = ex
19038 
 
19039 
  def read(self, iprot):
19040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19042 
      return
19043 
    iprot.readStructBegin()
19044 
    while True:
19045 
      (fname, ftype, fid) = iprot.readFieldBegin()
19046 
      if ftype == TType.STOP:
19047 
        break
19048 
      if fid == 1:
19049 
        if ftype == TType.STRUCT:
19050 
          self.ex = TransactionServiceException()
19051 
          self.ex.read(iprot)
19052 
        else:
19053 
          iprot.skip(ftype)
19054 
      else:
19055 
        iprot.skip(ftype)
19056 
      iprot.readFieldEnd()
19057 
    iprot.readStructEnd()
19058 
 
19059 
  def write(self, oprot):
19060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19062 
      return
19063 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19064 
    if self.ex is not None:
19065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19066 
      self.ex.write(oprot)
19067 
      oprot.writeFieldEnd()
19068 
    oprot.writeFieldStop()
19069 
    oprot.writeStructEnd()
19070 
 
19071 
  def validate(self):
19072 
    return
19073 
 
19074 
 
19075 
  def __repr__(self):
19076 
    L = ['%s=%r' % (key, value)
19077 
      for key, value in self.__dict__.iteritems()]
19078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19079 
 
19080 
  def __eq__(self, other):
19081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19082 
 
19083 
  def __ne__(self, other):
19084 
    return not (self == other)
19085 
 
4258 rajveer 19086 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19087 
  """
19088 
  Attributes:
4258 rajveer 19089 
   - transactionId
4247 rajveer 19090 
  """
19091 
 
19092 
  thrift_spec = (
19093 
    None, # 0
4258 rajveer 19094 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19095 
  )
19096 
 
4258 rajveer 19097 
  def __init__(self, transactionId=None,):
19098 
    self.transactionId = transactionId
4247 rajveer 19099 
 
19100 
  def read(self, iprot):
19101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19103 
      return
19104 
    iprot.readStructBegin()
19105 
    while True:
19106 
      (fname, ftype, fid) = iprot.readFieldBegin()
19107 
      if ftype == TType.STOP:
19108 
        break
19109 
      if fid == 1:
19110 
        if ftype == TType.I64:
4258 rajveer 19111 
          self.transactionId = iprot.readI64();
4247 rajveer 19112 
        else:
19113 
          iprot.skip(ftype)
19114 
      else:
19115 
        iprot.skip(ftype)
19116 
      iprot.readFieldEnd()
19117 
    iprot.readStructEnd()
19118 
 
19119 
  def write(self, oprot):
19120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19122 
      return
4258 rajveer 19123 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19124 
    if self.transactionId is not None:
19125 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19126 
      oprot.writeI64(self.transactionId)
4247 rajveer 19127 
      oprot.writeFieldEnd()
19128 
    oprot.writeFieldStop()
19129 
    oprot.writeStructEnd()
19130 
 
19131 
  def validate(self):
19132 
    return
19133 
 
19134 
 
19135 
  def __repr__(self):
19136 
    L = ['%s=%r' % (key, value)
19137 
      for key, value in self.__dict__.iteritems()]
19138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19139 
 
19140 
  def __eq__(self, other):
19141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19142 
 
19143 
  def __ne__(self, other):
19144 
    return not (self == other)
19145 
 
4258 rajveer 19146 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19147 
  """
19148 
  Attributes:
19149 
   - ex
19150 
  """
19151 
 
19152 
  thrift_spec = (
19153 
    None, # 0
19154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19155 
  )
19156 
 
19157 
  def __init__(self, ex=None,):
19158 
    self.ex = ex
19159 
 
19160 
  def read(self, iprot):
19161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19163 
      return
19164 
    iprot.readStructBegin()
19165 
    while True:
19166 
      (fname, ftype, fid) = iprot.readFieldBegin()
19167 
      if ftype == TType.STOP:
19168 
        break
19169 
      if fid == 1:
19170 
        if ftype == TType.STRUCT:
19171 
          self.ex = TransactionServiceException()
19172 
          self.ex.read(iprot)
19173 
        else:
19174 
          iprot.skip(ftype)
19175 
      else:
19176 
        iprot.skip(ftype)
19177 
      iprot.readFieldEnd()
19178 
    iprot.readStructEnd()
19179 
 
19180 
  def write(self, oprot):
19181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19183 
      return
4258 rajveer 19184 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19185 
    if self.ex is not None:
19186 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19187 
      self.ex.write(oprot)
19188 
      oprot.writeFieldEnd()
19189 
    oprot.writeFieldStop()
19190 
    oprot.writeStructEnd()
19191 
 
19192 
  def validate(self):
19193 
    return
19194 
 
19195 
 
19196 
  def __repr__(self):
19197 
    L = ['%s=%r' % (key, value)
19198 
      for key, value in self.__dict__.iteritems()]
19199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19200 
 
19201 
  def __eq__(self, other):
19202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19203 
 
19204 
  def __ne__(self, other):
19205 
    return not (self == other)
4259 anupam.sin 19206 
 
19207 
class refundTransaction_args:
19208 
  """
19209 
  Attributes:
19210 
   - transactionId
19211 
   - refundedBy
19212 
   - reason
19213 
  """
19214 
 
19215 
  thrift_spec = (
19216 
    None, # 0
19217 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19218 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19219 
    (3, TType.STRING, 'reason', None, None, ), # 3
19220 
  )
19221 
 
19222 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19223 
    self.transactionId = transactionId
19224 
    self.refundedBy = refundedBy
19225 
    self.reason = reason
19226 
 
19227 
  def read(self, iprot):
19228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19230 
      return
19231 
    iprot.readStructBegin()
19232 
    while True:
19233 
      (fname, ftype, fid) = iprot.readFieldBegin()
19234 
      if ftype == TType.STOP:
19235 
        break
19236 
      if fid == 1:
19237 
        if ftype == TType.I64:
19238 
          self.transactionId = iprot.readI64();
19239 
        else:
19240 
          iprot.skip(ftype)
19241 
      elif fid == 2:
19242 
        if ftype == TType.STRING:
19243 
          self.refundedBy = iprot.readString();
19244 
        else:
19245 
          iprot.skip(ftype)
19246 
      elif fid == 3:
19247 
        if ftype == TType.STRING:
19248 
          self.reason = iprot.readString();
19249 
        else:
19250 
          iprot.skip(ftype)
19251 
      else:
19252 
        iprot.skip(ftype)
19253 
      iprot.readFieldEnd()
19254 
    iprot.readStructEnd()
19255 
 
19256 
  def write(self, oprot):
19257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19259 
      return
19260 
    oprot.writeStructBegin('refundTransaction_args')
19261 
    if self.transactionId is not None:
19262 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19263 
      oprot.writeI64(self.transactionId)
19264 
      oprot.writeFieldEnd()
19265 
    if self.refundedBy is not None:
19266 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19267 
      oprot.writeString(self.refundedBy)
19268 
      oprot.writeFieldEnd()
19269 
    if self.reason is not None:
19270 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19271 
      oprot.writeString(self.reason)
19272 
      oprot.writeFieldEnd()
19273 
    oprot.writeFieldStop()
19274 
    oprot.writeStructEnd()
19275 
 
19276 
  def validate(self):
19277 
    return
19278 
 
19279 
 
19280 
  def __repr__(self):
19281 
    L = ['%s=%r' % (key, value)
19282 
      for key, value in self.__dict__.iteritems()]
19283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19284 
 
19285 
  def __eq__(self, other):
19286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19287 
 
19288 
  def __ne__(self, other):
19289 
    return not (self == other)
19290 
 
19291 
class refundTransaction_result:
19292 
  """
19293 
  Attributes:
19294 
   - ex
19295 
  """
19296 
 
19297 
  thrift_spec = (
19298 
    None, # 0
19299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19300 
  )
19301 
 
19302 
  def __init__(self, ex=None,):
19303 
    self.ex = ex
19304 
 
19305 
  def read(self, iprot):
19306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19308 
      return
19309 
    iprot.readStructBegin()
19310 
    while True:
19311 
      (fname, ftype, fid) = iprot.readFieldBegin()
19312 
      if ftype == TType.STOP:
19313 
        break
19314 
      if fid == 1:
19315 
        if ftype == TType.STRUCT:
19316 
          self.ex = TransactionServiceException()
19317 
          self.ex.read(iprot)
19318 
        else:
19319 
          iprot.skip(ftype)
19320 
      else:
19321 
        iprot.skip(ftype)
19322 
      iprot.readFieldEnd()
19323 
    iprot.readStructEnd()
19324 
 
19325 
  def write(self, oprot):
19326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19328 
      return
19329 
    oprot.writeStructBegin('refundTransaction_result')
19330 
    if self.ex is not None:
19331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19332 
      self.ex.write(oprot)
19333 
      oprot.writeFieldEnd()
19334 
    oprot.writeFieldStop()
19335 
    oprot.writeStructEnd()
19336 
 
19337 
  def validate(self):
19338 
    return
19339 
 
19340 
 
19341 
  def __repr__(self):
19342 
    L = ['%s=%r' % (key, value)
19343 
      for key, value in self.__dict__.iteritems()]
19344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19345 
 
19346 
  def __eq__(self, other):
19347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19348 
 
19349 
  def __ne__(self, other):
19350 
    return not (self == other)
4285 rajveer 19351 
 
4324 mandeep.dh 19352 
class updateShipmentAddress_args:
19353 
  """
19354 
  Attributes:
19355 
   - orderId
19356 
   - addressId
19357 
  """
19358 
 
19359 
  thrift_spec = (
19360 
    None, # 0
19361 
    (1, TType.I64, 'orderId', None, None, ), # 1
19362 
    (2, TType.I64, 'addressId', None, None, ), # 2
19363 
  )
19364 
 
19365 
  def __init__(self, orderId=None, addressId=None,):
19366 
    self.orderId = orderId
19367 
    self.addressId = addressId
19368 
 
19369 
  def read(self, iprot):
19370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19372 
      return
19373 
    iprot.readStructBegin()
19374 
    while True:
19375 
      (fname, ftype, fid) = iprot.readFieldBegin()
19376 
      if ftype == TType.STOP:
19377 
        break
19378 
      if fid == 1:
19379 
        if ftype == TType.I64:
19380 
          self.orderId = iprot.readI64();
19381 
        else:
19382 
          iprot.skip(ftype)
19383 
      elif fid == 2:
19384 
        if ftype == TType.I64:
19385 
          self.addressId = iprot.readI64();
19386 
        else:
19387 
          iprot.skip(ftype)
19388 
      else:
19389 
        iprot.skip(ftype)
19390 
      iprot.readFieldEnd()
19391 
    iprot.readStructEnd()
19392 
 
19393 
  def write(self, oprot):
19394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19396 
      return
19397 
    oprot.writeStructBegin('updateShipmentAddress_args')
19398 
    if self.orderId is not None:
19399 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19400 
      oprot.writeI64(self.orderId)
19401 
      oprot.writeFieldEnd()
19402 
    if self.addressId is not None:
19403 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19404 
      oprot.writeI64(self.addressId)
19405 
      oprot.writeFieldEnd()
19406 
    oprot.writeFieldStop()
19407 
    oprot.writeStructEnd()
19408 
 
19409 
  def validate(self):
19410 
    return
19411 
 
19412 
 
19413 
  def __repr__(self):
19414 
    L = ['%s=%r' % (key, value)
19415 
      for key, value in self.__dict__.iteritems()]
19416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19417 
 
19418 
  def __eq__(self, other):
19419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19420 
 
19421 
  def __ne__(self, other):
19422 
    return not (self == other)
19423 
 
19424 
class updateShipmentAddress_result:
19425 
  """
19426 
  Attributes:
19427 
   - ex
19428 
  """
19429 
 
19430 
  thrift_spec = (
19431 
    None, # 0
19432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19433 
  )
19434 
 
19435 
  def __init__(self, ex=None,):
19436 
    self.ex = ex
19437 
 
19438 
  def read(self, iprot):
19439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19441 
      return
19442 
    iprot.readStructBegin()
19443 
    while True:
19444 
      (fname, ftype, fid) = iprot.readFieldBegin()
19445 
      if ftype == TType.STOP:
19446 
        break
19447 
      if fid == 1:
19448 
        if ftype == TType.STRUCT:
19449 
          self.ex = TransactionServiceException()
19450 
          self.ex.read(iprot)
19451 
        else:
19452 
          iprot.skip(ftype)
19453 
      else:
19454 
        iprot.skip(ftype)
19455 
      iprot.readFieldEnd()
19456 
    iprot.readStructEnd()
19457 
 
19458 
  def write(self, oprot):
19459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19461 
      return
19462 
    oprot.writeStructBegin('updateShipmentAddress_result')
19463 
    if self.ex is not None:
19464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19465 
      self.ex.write(oprot)
19466 
      oprot.writeFieldEnd()
19467 
    oprot.writeFieldStop()
19468 
    oprot.writeStructEnd()
19469 
 
19470 
  def validate(self):
19471 
    return
19472 
 
19473 
 
19474 
  def __repr__(self):
19475 
    L = ['%s=%r' % (key, value)
19476 
      for key, value in self.__dict__.iteritems()]
19477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19478 
 
19479 
  def __eq__(self, other):
19480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19481 
 
19482 
  def __ne__(self, other):
19483 
    return not (self == other)
19484 
 
4285 rajveer 19485 
class acceptOrdersForItemId_args:
19486 
  """
19487 
  Attributes:
19488 
   - itemId
19489 
   - inventory
19490 
  """
19491 
 
19492 
  thrift_spec = (
19493 
    None, # 0
19494 
    (1, TType.I64, 'itemId', None, None, ), # 1
19495 
    (2, TType.I64, 'inventory', None, None, ), # 2
19496 
  )
19497 
 
19498 
  def __init__(self, itemId=None, inventory=None,):
19499 
    self.itemId = itemId
19500 
    self.inventory = inventory
19501 
 
19502 
  def read(self, iprot):
19503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19505 
      return
19506 
    iprot.readStructBegin()
19507 
    while True:
19508 
      (fname, ftype, fid) = iprot.readFieldBegin()
19509 
      if ftype == TType.STOP:
19510 
        break
19511 
      if fid == 1:
19512 
        if ftype == TType.I64:
19513 
          self.itemId = iprot.readI64();
19514 
        else:
19515 
          iprot.skip(ftype)
19516 
      elif fid == 2:
19517 
        if ftype == TType.I64:
19518 
          self.inventory = iprot.readI64();
19519 
        else:
19520 
          iprot.skip(ftype)
19521 
      else:
19522 
        iprot.skip(ftype)
19523 
      iprot.readFieldEnd()
19524 
    iprot.readStructEnd()
19525 
 
19526 
  def write(self, oprot):
19527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19529 
      return
19530 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19531 
    if self.itemId is not None:
19532 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19533 
      oprot.writeI64(self.itemId)
19534 
      oprot.writeFieldEnd()
19535 
    if self.inventory is not None:
19536 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19537 
      oprot.writeI64(self.inventory)
19538 
      oprot.writeFieldEnd()
19539 
    oprot.writeFieldStop()
19540 
    oprot.writeStructEnd()
19541 
 
19542 
  def validate(self):
19543 
    return
19544 
 
19545 
 
19546 
  def __repr__(self):
19547 
    L = ['%s=%r' % (key, value)
19548 
      for key, value in self.__dict__.iteritems()]
19549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19550 
 
19551 
  def __eq__(self, other):
19552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19553 
 
19554 
  def __ne__(self, other):
19555 
    return not (self == other)
19556 
 
19557 
class acceptOrdersForItemId_result:
19558 
  """
19559 
  Attributes:
19560 
   - success
19561 
   - ex
19562 
  """
19563 
 
19564 
  thrift_spec = (
19565 
    (0, TType.BOOL, 'success', None, None, ), # 0
19566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19567 
  )
19568 
 
19569 
  def __init__(self, success=None, ex=None,):
19570 
    self.success = success
19571 
    self.ex = ex
19572 
 
19573 
  def read(self, iprot):
19574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19576 
      return
19577 
    iprot.readStructBegin()
19578 
    while True:
19579 
      (fname, ftype, fid) = iprot.readFieldBegin()
19580 
      if ftype == TType.STOP:
19581 
        break
19582 
      if fid == 0:
19583 
        if ftype == TType.BOOL:
19584 
          self.success = iprot.readBool();
19585 
        else:
19586 
          iprot.skip(ftype)
19587 
      elif fid == 1:
19588 
        if ftype == TType.STRUCT:
19589 
          self.ex = TransactionServiceException()
19590 
          self.ex.read(iprot)
19591 
        else:
19592 
          iprot.skip(ftype)
19593 
      else:
19594 
        iprot.skip(ftype)
19595 
      iprot.readFieldEnd()
19596 
    iprot.readStructEnd()
19597 
 
19598 
  def write(self, oprot):
19599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19601 
      return
19602 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
19603 
    if self.success is not None:
19604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19605 
      oprot.writeBool(self.success)
19606 
      oprot.writeFieldEnd()
19607 
    if self.ex is not None:
19608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19609 
      self.ex.write(oprot)
19610 
      oprot.writeFieldEnd()
19611 
    oprot.writeFieldStop()
19612 
    oprot.writeStructEnd()
19613 
 
19614 
  def validate(self):
19615 
    return
19616 
 
19617 
 
19618 
  def __repr__(self):
19619 
    L = ['%s=%r' % (key, value)
19620 
      for key, value in self.__dict__.iteritems()]
19621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19622 
 
19623 
  def __eq__(self, other):
19624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19625 
 
19626 
  def __ne__(self, other):
19627 
    return not (self == other)
4303 rajveer 19628 
 
19629 
class markOrdersAsPORaised_args:
19630 
  """
19631 
  Attributes:
19632 
   - vendorId
19633 
   - itemId
19634 
   - quantity
19635 
   - estimate
4369 rajveer 19636 
   - isReminder
4303 rajveer 19637 
  """
19638 
 
19639 
  thrift_spec = (
19640 
    None, # 0
19641 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19642 
    (2, TType.I64, 'itemId', None, None, ), # 2
19643 
    (3, TType.I64, 'quantity', None, None, ), # 3
19644 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19645 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19646 
  )
19647 
 
4369 rajveer 19648 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19649 
    self.vendorId = vendorId
19650 
    self.itemId = itemId
19651 
    self.quantity = quantity
19652 
    self.estimate = estimate
4369 rajveer 19653 
    self.isReminder = isReminder
4303 rajveer 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.I64:
19666 
          self.vendorId = iprot.readI64();
19667 
        else:
19668 
          iprot.skip(ftype)
19669 
      elif fid == 2:
19670 
        if ftype == TType.I64:
19671 
          self.itemId = iprot.readI64();
19672 
        else:
19673 
          iprot.skip(ftype)
19674 
      elif fid == 3:
19675 
        if ftype == TType.I64:
19676 
          self.quantity = iprot.readI64();
19677 
        else:
19678 
          iprot.skip(ftype)
19679 
      elif fid == 4:
19680 
        if ftype == TType.I64:
19681 
          self.estimate = iprot.readI64();
19682 
        else:
19683 
          iprot.skip(ftype)
4369 rajveer 19684 
      elif fid == 5:
19685 
        if ftype == TType.BOOL:
19686 
          self.isReminder = iprot.readBool();
19687 
        else:
19688 
          iprot.skip(ftype)
4303 rajveer 19689 
      else:
19690 
        iprot.skip(ftype)
19691 
      iprot.readFieldEnd()
19692 
    iprot.readStructEnd()
19693 
 
19694 
  def write(self, oprot):
19695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19697 
      return
19698 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19699 
    if self.vendorId is not None:
19700 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19701 
      oprot.writeI64(self.vendorId)
19702 
      oprot.writeFieldEnd()
19703 
    if self.itemId is not None:
19704 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19705 
      oprot.writeI64(self.itemId)
19706 
      oprot.writeFieldEnd()
19707 
    if self.quantity is not None:
19708 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19709 
      oprot.writeI64(self.quantity)
19710 
      oprot.writeFieldEnd()
19711 
    if self.estimate is not None:
19712 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19713 
      oprot.writeI64(self.estimate)
19714 
      oprot.writeFieldEnd()
4369 rajveer 19715 
    if self.isReminder is not None:
19716 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19717 
      oprot.writeBool(self.isReminder)
19718 
      oprot.writeFieldEnd()
4303 rajveer 19719 
    oprot.writeFieldStop()
19720 
    oprot.writeStructEnd()
19721 
 
19722 
  def validate(self):
19723 
    return
19724 
 
19725 
 
19726 
  def __repr__(self):
19727 
    L = ['%s=%r' % (key, value)
19728 
      for key, value in self.__dict__.iteritems()]
19729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19730 
 
19731 
  def __eq__(self, other):
19732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19733 
 
19734 
  def __ne__(self, other):
19735 
    return not (self == other)
19736 
 
19737 
class markOrdersAsPORaised_result:
19738 
  """
19739 
  Attributes:
19740 
   - ex
19741 
  """
19742 
 
19743 
  thrift_spec = (
19744 
    None, # 0
19745 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19746 
  )
19747 
 
19748 
  def __init__(self, ex=None,):
19749 
    self.ex = ex
19750 
 
19751 
  def read(self, iprot):
19752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19754 
      return
19755 
    iprot.readStructBegin()
19756 
    while True:
19757 
      (fname, ftype, fid) = iprot.readFieldBegin()
19758 
      if ftype == TType.STOP:
19759 
        break
19760 
      if fid == 1:
19761 
        if ftype == TType.STRUCT:
19762 
          self.ex = TransactionServiceException()
19763 
          self.ex.read(iprot)
19764 
        else:
19765 
          iprot.skip(ftype)
19766 
      else:
19767 
        iprot.skip(ftype)
19768 
      iprot.readFieldEnd()
19769 
    iprot.readStructEnd()
19770 
 
19771 
  def write(self, oprot):
19772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19774 
      return
19775 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19776 
    if self.ex is not None:
19777 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19778 
      self.ex.write(oprot)
19779 
      oprot.writeFieldEnd()
19780 
    oprot.writeFieldStop()
19781 
    oprot.writeStructEnd()
19782 
 
19783 
  def validate(self):
19784 
    return
19785 
 
19786 
 
19787 
  def __repr__(self):
19788 
    L = ['%s=%r' % (key, value)
19789 
      for key, value in self.__dict__.iteritems()]
19790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19791 
 
19792 
  def __eq__(self, other):
19793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19794 
 
19795 
  def __ne__(self, other):
19796 
    return not (self == other)
19797 
 
19798 
class markOrdersAsReversalInitiated_args:
19799 
  """
19800 
  Attributes:
19801 
   - vendorId
19802 
   - itemId
19803 
   - quantity
19804 
   - estimate
4369 rajveer 19805 
   - isReminder
4303 rajveer 19806 
  """
19807 
 
19808 
  thrift_spec = (
19809 
    None, # 0
19810 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19811 
    (2, TType.I64, 'itemId', None, None, ), # 2
19812 
    (3, TType.I64, 'quantity', None, None, ), # 3
19813 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19814 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19815 
  )
19816 
 
4369 rajveer 19817 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19818 
    self.vendorId = vendorId
19819 
    self.itemId = itemId
19820 
    self.quantity = quantity
19821 
    self.estimate = estimate
4369 rajveer 19822 
    self.isReminder = isReminder
4303 rajveer 19823 
 
19824 
  def read(self, iprot):
19825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19827 
      return
19828 
    iprot.readStructBegin()
19829 
    while True:
19830 
      (fname, ftype, fid) = iprot.readFieldBegin()
19831 
      if ftype == TType.STOP:
19832 
        break
19833 
      if fid == 1:
19834 
        if ftype == TType.I64:
19835 
          self.vendorId = iprot.readI64();
19836 
        else:
19837 
          iprot.skip(ftype)
19838 
      elif fid == 2:
19839 
        if ftype == TType.I64:
19840 
          self.itemId = iprot.readI64();
19841 
        else:
19842 
          iprot.skip(ftype)
19843 
      elif fid == 3:
19844 
        if ftype == TType.I64:
19845 
          self.quantity = iprot.readI64();
19846 
        else:
19847 
          iprot.skip(ftype)
19848 
      elif fid == 4:
19849 
        if ftype == TType.I64:
19850 
          self.estimate = iprot.readI64();
19851 
        else:
19852 
          iprot.skip(ftype)
4369 rajveer 19853 
      elif fid == 5:
19854 
        if ftype == TType.BOOL:
19855 
          self.isReminder = iprot.readBool();
19856 
        else:
19857 
          iprot.skip(ftype)
4303 rajveer 19858 
      else:
19859 
        iprot.skip(ftype)
19860 
      iprot.readFieldEnd()
19861 
    iprot.readStructEnd()
19862 
 
19863 
  def write(self, oprot):
19864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19866 
      return
19867 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19868 
    if self.vendorId is not None:
19869 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19870 
      oprot.writeI64(self.vendorId)
19871 
      oprot.writeFieldEnd()
19872 
    if self.itemId is not None:
19873 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19874 
      oprot.writeI64(self.itemId)
19875 
      oprot.writeFieldEnd()
19876 
    if self.quantity is not None:
19877 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19878 
      oprot.writeI64(self.quantity)
19879 
      oprot.writeFieldEnd()
19880 
    if self.estimate is not None:
19881 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19882 
      oprot.writeI64(self.estimate)
19883 
      oprot.writeFieldEnd()
4369 rajveer 19884 
    if self.isReminder is not None:
19885 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19886 
      oprot.writeBool(self.isReminder)
19887 
      oprot.writeFieldEnd()
4303 rajveer 19888 
    oprot.writeFieldStop()
19889 
    oprot.writeStructEnd()
19890 
 
19891 
  def validate(self):
19892 
    return
19893 
 
19894 
 
19895 
  def __repr__(self):
19896 
    L = ['%s=%r' % (key, value)
19897 
      for key, value in self.__dict__.iteritems()]
19898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19899 
 
19900 
  def __eq__(self, other):
19901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19902 
 
19903 
  def __ne__(self, other):
19904 
    return not (self == other)
19905 
 
19906 
class markOrdersAsReversalInitiated_result:
19907 
  """
19908 
  Attributes:
19909 
   - ex
19910 
  """
19911 
 
19912 
  thrift_spec = (
19913 
    None, # 0
19914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19915 
  )
19916 
 
19917 
  def __init__(self, ex=None,):
19918 
    self.ex = ex
19919 
 
19920 
  def read(self, iprot):
19921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19923 
      return
19924 
    iprot.readStructBegin()
19925 
    while True:
19926 
      (fname, ftype, fid) = iprot.readFieldBegin()
19927 
      if ftype == TType.STOP:
19928 
        break
19929 
      if fid == 1:
19930 
        if ftype == TType.STRUCT:
19931 
          self.ex = TransactionServiceException()
19932 
          self.ex.read(iprot)
19933 
        else:
19934 
          iprot.skip(ftype)
19935 
      else:
19936 
        iprot.skip(ftype)
19937 
      iprot.readFieldEnd()
19938 
    iprot.readStructEnd()
19939 
 
19940 
  def write(self, oprot):
19941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19943 
      return
19944 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19945 
    if self.ex is not None:
19946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19947 
      self.ex.write(oprot)
19948 
      oprot.writeFieldEnd()
19949 
    oprot.writeFieldStop()
19950 
    oprot.writeStructEnd()
19951 
 
19952 
  def validate(self):
19953 
    return
19954 
 
19955 
 
19956 
  def __repr__(self):
19957 
    L = ['%s=%r' % (key, value)
19958 
      for key, value in self.__dict__.iteritems()]
19959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19960 
 
19961 
  def __eq__(self, other):
19962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19963 
 
19964 
  def __ne__(self, other):
19965 
    return not (self == other)
19966 
 
19967 
class markOrdersAsNotAvailabke_args:
19968 
  """
19969 
  Attributes:
19970 
   - vendorId
19971 
   - itemId
19972 
   - quantity
19973 
   - estimate
4369 rajveer 19974 
   - isReminder
4303 rajveer 19975 
  """
19976 
 
19977 
  thrift_spec = (
19978 
    None, # 0
19979 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19980 
    (2, TType.I64, 'itemId', None, None, ), # 2
19981 
    (3, TType.I64, 'quantity', None, None, ), # 3
19982 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19983 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19984 
  )
19985 
 
4369 rajveer 19986 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19987 
    self.vendorId = vendorId
19988 
    self.itemId = itemId
19989 
    self.quantity = quantity
19990 
    self.estimate = estimate
4369 rajveer 19991 
    self.isReminder = isReminder
4303 rajveer 19992 
 
19993 
  def read(self, iprot):
19994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19996 
      return
19997 
    iprot.readStructBegin()
19998 
    while True:
19999 
      (fname, ftype, fid) = iprot.readFieldBegin()
20000 
      if ftype == TType.STOP:
20001 
        break
20002 
      if fid == 1:
20003 
        if ftype == TType.I64:
20004 
          self.vendorId = iprot.readI64();
20005 
        else:
20006 
          iprot.skip(ftype)
20007 
      elif fid == 2:
20008 
        if ftype == TType.I64:
20009 
          self.itemId = iprot.readI64();
20010 
        else:
20011 
          iprot.skip(ftype)
20012 
      elif fid == 3:
20013 
        if ftype == TType.I64:
20014 
          self.quantity = iprot.readI64();
20015 
        else:
20016 
          iprot.skip(ftype)
20017 
      elif fid == 4:
20018 
        if ftype == TType.I64:
20019 
          self.estimate = iprot.readI64();
20020 
        else:
20021 
          iprot.skip(ftype)
4369 rajveer 20022 
      elif fid == 5:
20023 
        if ftype == TType.BOOL:
20024 
          self.isReminder = iprot.readBool();
20025 
        else:
20026 
          iprot.skip(ftype)
4303 rajveer 20027 
      else:
20028 
        iprot.skip(ftype)
20029 
      iprot.readFieldEnd()
20030 
    iprot.readStructEnd()
20031 
 
20032 
  def write(self, oprot):
20033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20035 
      return
20036 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20037 
    if self.vendorId is not None:
20038 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20039 
      oprot.writeI64(self.vendorId)
20040 
      oprot.writeFieldEnd()
20041 
    if self.itemId is not None:
20042 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20043 
      oprot.writeI64(self.itemId)
20044 
      oprot.writeFieldEnd()
20045 
    if self.quantity is not None:
20046 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20047 
      oprot.writeI64(self.quantity)
20048 
      oprot.writeFieldEnd()
20049 
    if self.estimate is not None:
20050 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20051 
      oprot.writeI64(self.estimate)
20052 
      oprot.writeFieldEnd()
4369 rajveer 20053 
    if self.isReminder is not None:
20054 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20055 
      oprot.writeBool(self.isReminder)
20056 
      oprot.writeFieldEnd()
4303 rajveer 20057 
    oprot.writeFieldStop()
20058 
    oprot.writeStructEnd()
20059 
 
20060 
  def validate(self):
20061 
    return
20062 
 
20063 
 
20064 
  def __repr__(self):
20065 
    L = ['%s=%r' % (key, value)
20066 
      for key, value in self.__dict__.iteritems()]
20067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20068 
 
20069 
  def __eq__(self, other):
20070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20071 
 
20072 
  def __ne__(self, other):
20073 
    return not (self == other)
20074 
 
20075 
class markOrdersAsNotAvailabke_result:
20076 
  """
20077 
  Attributes:
20078 
   - ex
20079 
  """
20080 
 
20081 
  thrift_spec = (
20082 
    None, # 0
20083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20084 
  )
20085 
 
20086 
  def __init__(self, ex=None,):
20087 
    self.ex = ex
20088 
 
20089 
  def read(self, iprot):
20090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20092 
      return
20093 
    iprot.readStructBegin()
20094 
    while True:
20095 
      (fname, ftype, fid) = iprot.readFieldBegin()
20096 
      if ftype == TType.STOP:
20097 
        break
20098 
      if fid == 1:
20099 
        if ftype == TType.STRUCT:
20100 
          self.ex = TransactionServiceException()
20101 
          self.ex.read(iprot)
20102 
        else:
20103 
          iprot.skip(ftype)
20104 
      else:
20105 
        iprot.skip(ftype)
20106 
      iprot.readFieldEnd()
20107 
    iprot.readStructEnd()
20108 
 
20109 
  def write(self, oprot):
20110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20112 
      return
20113 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20114 
    if self.ex is not None:
20115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20116 
      self.ex.write(oprot)
20117 
      oprot.writeFieldEnd()
20118 
    oprot.writeFieldStop()
20119 
    oprot.writeStructEnd()
20120 
 
20121 
  def validate(self):
20122 
    return
20123 
 
20124 
 
20125 
  def __repr__(self):
20126 
    L = ['%s=%r' % (key, value)
20127 
      for key, value in self.__dict__.iteritems()]
20128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20129 
 
20130 
  def __eq__(self, other):
20131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20132 
 
20133 
  def __ne__(self, other):
20134 
    return not (self == other)
4369 rajveer 20135 
 
20136 
class markOrdersAsTimeout_args:
20137 
  """
20138 
  Attributes:
20139 
   - vendorId
20140 
  """
20141 
 
20142 
  thrift_spec = (
20143 
    None, # 0
20144 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20145 
  )
20146 
 
20147 
  def __init__(self, vendorId=None,):
20148 
    self.vendorId = vendorId
20149 
 
20150 
  def read(self, iprot):
20151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20153 
      return
20154 
    iprot.readStructBegin()
20155 
    while True:
20156 
      (fname, ftype, fid) = iprot.readFieldBegin()
20157 
      if ftype == TType.STOP:
20158 
        break
20159 
      if fid == 1:
20160 
        if ftype == TType.I64:
20161 
          self.vendorId = iprot.readI64();
20162 
        else:
20163 
          iprot.skip(ftype)
20164 
      else:
20165 
        iprot.skip(ftype)
20166 
      iprot.readFieldEnd()
20167 
    iprot.readStructEnd()
20168 
 
20169 
  def write(self, oprot):
20170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20172 
      return
20173 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20174 
    if self.vendorId is not None:
20175 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20176 
      oprot.writeI64(self.vendorId)
20177 
      oprot.writeFieldEnd()
20178 
    oprot.writeFieldStop()
20179 
    oprot.writeStructEnd()
20180 
 
20181 
  def validate(self):
20182 
    return
20183 
 
20184 
 
20185 
  def __repr__(self):
20186 
    L = ['%s=%r' % (key, value)
20187 
      for key, value in self.__dict__.iteritems()]
20188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20189 
 
20190 
  def __eq__(self, other):
20191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20192 
 
20193 
  def __ne__(self, other):
20194 
    return not (self == other)
20195 
 
20196 
class markOrdersAsTimeout_result:
20197 
  """
20198 
  Attributes:
20199 
   - success
20200 
   - ex
20201 
  """
20202 
 
20203 
  thrift_spec = (
20204 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20206 
  )
20207 
 
20208 
  def __init__(self, success=None, ex=None,):
20209 
    self.success = success
20210 
    self.ex = ex
20211 
 
20212 
  def read(self, iprot):
20213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20215 
      return
20216 
    iprot.readStructBegin()
20217 
    while True:
20218 
      (fname, ftype, fid) = iprot.readFieldBegin()
20219 
      if ftype == TType.STOP:
20220 
        break
20221 
      if fid == 0:
20222 
        if ftype == TType.MAP:
20223 
          self.success = {}
5481 phani.kuma 20224 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
20225 
          for _i448 in xrange(_size444):
20226 
            _key449 = iprot.readI32();
20227 
            _val450 = TimeoutSummary()
20228 
            _val450.read(iprot)
20229 
            self.success[_key449] = _val450
4369 rajveer 20230 
          iprot.readMapEnd()
20231 
        else:
20232 
          iprot.skip(ftype)
20233 
      elif fid == 1:
20234 
        if ftype == TType.STRUCT:
20235 
          self.ex = TransactionServiceException()
20236 
          self.ex.read(iprot)
20237 
        else:
20238 
          iprot.skip(ftype)
20239 
      else:
20240 
        iprot.skip(ftype)
20241 
      iprot.readFieldEnd()
20242 
    iprot.readStructEnd()
20243 
 
20244 
  def write(self, oprot):
20245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20247 
      return
20248 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20249 
    if self.success is not None:
20250 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20251 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5481 phani.kuma 20252 
      for kiter451,viter452 in self.success.items():
20253 
        oprot.writeI32(kiter451)
20254 
        viter452.write(oprot)
4369 rajveer 20255 
      oprot.writeMapEnd()
20256 
      oprot.writeFieldEnd()
20257 
    if self.ex is not None:
20258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20259 
      self.ex.write(oprot)
20260 
      oprot.writeFieldEnd()
20261 
    oprot.writeFieldStop()
20262 
    oprot.writeStructEnd()
20263 
 
20264 
  def validate(self):
20265 
    return
20266 
 
20267 
 
20268 
  def __repr__(self):
20269 
    L = ['%s=%r' % (key, value)
20270 
      for key, value in self.__dict__.iteritems()]
20271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20272 
 
20273 
  def __eq__(self, other):
20274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20275 
 
20276 
  def __ne__(self, other):
20277 
    return not (self == other)
4386 anupam.sin 20278 
 
4662 rajveer 20279 
class markOrderAsLostInTransit_args:
20280 
  """
20281 
  Attributes:
20282 
   - orderId
20283 
  """
20284 
 
20285 
  thrift_spec = (
20286 
    None, # 0
20287 
    (1, TType.I64, 'orderId', None, None, ), # 1
20288 
  )
20289 
 
20290 
  def __init__(self, orderId=None,):
20291 
    self.orderId = orderId
20292 
 
20293 
  def read(self, iprot):
20294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20296 
      return
20297 
    iprot.readStructBegin()
20298 
    while True:
20299 
      (fname, ftype, fid) = iprot.readFieldBegin()
20300 
      if ftype == TType.STOP:
20301 
        break
20302 
      if fid == 1:
20303 
        if ftype == TType.I64:
20304 
          self.orderId = iprot.readI64();
20305 
        else:
20306 
          iprot.skip(ftype)
20307 
      else:
20308 
        iprot.skip(ftype)
20309 
      iprot.readFieldEnd()
20310 
    iprot.readStructEnd()
20311 
 
20312 
  def write(self, oprot):
20313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20315 
      return
20316 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20317 
    if self.orderId is not None:
20318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20319 
      oprot.writeI64(self.orderId)
20320 
      oprot.writeFieldEnd()
20321 
    oprot.writeFieldStop()
20322 
    oprot.writeStructEnd()
20323 
 
20324 
  def validate(self):
20325 
    return
20326 
 
20327 
 
20328 
  def __repr__(self):
20329 
    L = ['%s=%r' % (key, value)
20330 
      for key, value in self.__dict__.iteritems()]
20331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20332 
 
20333 
  def __eq__(self, other):
20334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20335 
 
20336 
  def __ne__(self, other):
20337 
    return not (self == other)
20338 
 
20339 
class markOrderAsLostInTransit_result:
20340 
  """
20341 
  Attributes:
20342 
   - success
20343 
   - ex
20344 
  """
20345 
 
20346 
  thrift_spec = (
20347 
    (0, TType.BOOL, 'success', None, None, ), # 0
20348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20349 
  )
20350 
 
20351 
  def __init__(self, success=None, ex=None,):
20352 
    self.success = success
20353 
    self.ex = ex
20354 
 
20355 
  def read(self, iprot):
20356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20358 
      return
20359 
    iprot.readStructBegin()
20360 
    while True:
20361 
      (fname, ftype, fid) = iprot.readFieldBegin()
20362 
      if ftype == TType.STOP:
20363 
        break
20364 
      if fid == 0:
20365 
        if ftype == TType.BOOL:
20366 
          self.success = iprot.readBool();
20367 
        else:
20368 
          iprot.skip(ftype)
20369 
      elif fid == 1:
20370 
        if ftype == TType.STRUCT:
20371 
          self.ex = TransactionServiceException()
20372 
          self.ex.read(iprot)
20373 
        else:
20374 
          iprot.skip(ftype)
20375 
      else:
20376 
        iprot.skip(ftype)
20377 
      iprot.readFieldEnd()
20378 
    iprot.readStructEnd()
20379 
 
20380 
  def write(self, oprot):
20381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20383 
      return
20384 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20385 
    if self.success is not None:
20386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20387 
      oprot.writeBool(self.success)
20388 
      oprot.writeFieldEnd()
20389 
    if self.ex is not None:
20390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20391 
      self.ex.write(oprot)
20392 
      oprot.writeFieldEnd()
20393 
    oprot.writeFieldStop()
20394 
    oprot.writeStructEnd()
20395 
 
20396 
  def validate(self):
20397 
    return
20398 
 
20399 
 
20400 
  def __repr__(self):
20401 
    L = ['%s=%r' % (key, value)
20402 
      for key, value in self.__dict__.iteritems()]
20403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20404 
 
20405 
  def __eq__(self, other):
20406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20407 
 
20408 
  def __ne__(self, other):
20409 
    return not (self == other)
20410 
 
4386 anupam.sin 20411 
class getOrderForAwb_args:
20412 
  """
20413 
  Attributes:
20414 
   - awb
20415 
  """
20416 
 
20417 
  thrift_spec = (
20418 
    None, # 0
20419 
    (1, TType.STRING, 'awb', None, None, ), # 1
20420 
  )
20421 
 
20422 
  def __init__(self, awb=None,):
20423 
    self.awb = awb
20424 
 
20425 
  def read(self, iprot):
20426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20428 
      return
20429 
    iprot.readStructBegin()
20430 
    while True:
20431 
      (fname, ftype, fid) = iprot.readFieldBegin()
20432 
      if ftype == TType.STOP:
20433 
        break
20434 
      if fid == 1:
20435 
        if ftype == TType.STRING:
20436 
          self.awb = iprot.readString();
20437 
        else:
20438 
          iprot.skip(ftype)
20439 
      else:
20440 
        iprot.skip(ftype)
20441 
      iprot.readFieldEnd()
20442 
    iprot.readStructEnd()
20443 
 
20444 
  def write(self, oprot):
20445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20447 
      return
20448 
    oprot.writeStructBegin('getOrderForAwb_args')
20449 
    if self.awb is not None:
20450 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20451 
      oprot.writeString(self.awb)
20452 
      oprot.writeFieldEnd()
20453 
    oprot.writeFieldStop()
20454 
    oprot.writeStructEnd()
20455 
 
20456 
  def validate(self):
20457 
    return
20458 
 
20459 
 
20460 
  def __repr__(self):
20461 
    L = ['%s=%r' % (key, value)
20462 
      for key, value in self.__dict__.iteritems()]
20463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20464 
 
20465 
  def __eq__(self, other):
20466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20467 
 
20468 
  def __ne__(self, other):
20469 
    return not (self == other)
20470 
 
20471 
class getOrderForAwb_result:
20472 
  """
20473 
  Attributes:
20474 
   - success
20475 
   - ex
20476 
  """
20477 
 
20478 
  thrift_spec = (
20479 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20481 
  )
20482 
 
20483 
  def __init__(self, success=None, ex=None,):
20484 
    self.success = success
20485 
    self.ex = ex
20486 
 
20487 
  def read(self, iprot):
20488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20490 
      return
20491 
    iprot.readStructBegin()
20492 
    while True:
20493 
      (fname, ftype, fid) = iprot.readFieldBegin()
20494 
      if ftype == TType.STOP:
20495 
        break
20496 
      if fid == 0:
20497 
        if ftype == TType.STRUCT:
20498 
          self.success = Order()
20499 
          self.success.read(iprot)
20500 
        else:
20501 
          iprot.skip(ftype)
20502 
      elif fid == 1:
20503 
        if ftype == TType.STRUCT:
20504 
          self.ex = TransactionServiceException()
20505 
          self.ex.read(iprot)
20506 
        else:
20507 
          iprot.skip(ftype)
20508 
      else:
20509 
        iprot.skip(ftype)
20510 
      iprot.readFieldEnd()
20511 
    iprot.readStructEnd()
20512 
 
20513 
  def write(self, oprot):
20514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20516 
      return
20517 
    oprot.writeStructBegin('getOrderForAwb_result')
20518 
    if self.success is not None:
20519 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20520 
      self.success.write(oprot)
20521 
      oprot.writeFieldEnd()
20522 
    if self.ex is not None:
20523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20524 
      self.ex.write(oprot)
20525 
      oprot.writeFieldEnd()
20526 
    oprot.writeFieldStop()
20527 
    oprot.writeStructEnd()
20528 
 
20529 
  def validate(self):
20530 
    return
20531 
 
20532 
 
20533 
  def __repr__(self):
20534 
    L = ['%s=%r' % (key, value)
20535 
      for key, value in self.__dict__.iteritems()]
20536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20537 
 
20538 
  def __eq__(self, other):
20539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20540 
 
20541 
  def __ne__(self, other):
20542 
    return not (self == other)
4506 phani.kuma 20543 
 
20544 
class getOrdersForProviderForStatus_args:
20545 
  """
20546 
  Attributes:
20547 
   - logistics_provider_id
4910 phani.kuma 20548 
   - order_status_list
4506 phani.kuma 20549 
  """
20550 
 
20551 
  thrift_spec = (
20552 
    None, # 0
20553 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20554 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20555 
  )
20556 
 
4910 phani.kuma 20557 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20558 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20559 
    self.order_status_list = order_status_list
4506 phani.kuma 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.logistics_provider_id = iprot.readI64();
20573 
        else:
20574 
          iprot.skip(ftype)
20575 
      elif fid == 2:
4910 phani.kuma 20576 
        if ftype == TType.LIST:
20577 
          self.order_status_list = []
5481 phani.kuma 20578 
          (_etype456, _size453) = iprot.readListBegin()
20579 
          for _i457 in xrange(_size453):
20580 
            _elem458 = iprot.readI32();
20581 
            self.order_status_list.append(_elem458)
4910 phani.kuma 20582 
          iprot.readListEnd()
4506 phani.kuma 20583 
        else:
20584 
          iprot.skip(ftype)
20585 
      else:
20586 
        iprot.skip(ftype)
20587 
      iprot.readFieldEnd()
20588 
    iprot.readStructEnd()
20589 
 
20590 
  def write(self, oprot):
20591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20593 
      return
20594 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
20595 
    if self.logistics_provider_id is not None:
20596 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
20597 
      oprot.writeI64(self.logistics_provider_id)
20598 
      oprot.writeFieldEnd()
4910 phani.kuma 20599 
    if self.order_status_list is not None:
20600 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
20601 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5481 phani.kuma 20602 
      for iter459 in self.order_status_list:
20603 
        oprot.writeI32(iter459)
4910 phani.kuma 20604 
      oprot.writeListEnd()
4506 phani.kuma 20605 
      oprot.writeFieldEnd()
20606 
    oprot.writeFieldStop()
20607 
    oprot.writeStructEnd()
20608 
 
20609 
  def validate(self):
20610 
    return
20611 
 
20612 
 
20613 
  def __repr__(self):
20614 
    L = ['%s=%r' % (key, value)
20615 
      for key, value in self.__dict__.iteritems()]
20616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20617 
 
20618 
  def __eq__(self, other):
20619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20620 
 
20621 
  def __ne__(self, other):
20622 
    return not (self == other)
20623 
 
20624 
class getOrdersForProviderForStatus_result:
20625 
  """
20626 
  Attributes:
20627 
   - success
20628 
   - ex
20629 
  """
20630 
 
20631 
  thrift_spec = (
20632 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20634 
  )
20635 
 
20636 
  def __init__(self, success=None, ex=None,):
20637 
    self.success = success
20638 
    self.ex = ex
20639 
 
20640 
  def read(self, iprot):
20641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20643 
      return
20644 
    iprot.readStructBegin()
20645 
    while True:
20646 
      (fname, ftype, fid) = iprot.readFieldBegin()
20647 
      if ftype == TType.STOP:
20648 
        break
20649 
      if fid == 0:
20650 
        if ftype == TType.LIST:
20651 
          self.success = []
5481 phani.kuma 20652 
          (_etype463, _size460) = iprot.readListBegin()
20653 
          for _i464 in xrange(_size460):
20654 
            _elem465 = Order()
20655 
            _elem465.read(iprot)
20656 
            self.success.append(_elem465)
4506 phani.kuma 20657 
          iprot.readListEnd()
20658 
        else:
20659 
          iprot.skip(ftype)
20660 
      elif fid == 1:
20661 
        if ftype == TType.STRUCT:
20662 
          self.ex = TransactionServiceException()
20663 
          self.ex.read(iprot)
20664 
        else:
20665 
          iprot.skip(ftype)
20666 
      else:
20667 
        iprot.skip(ftype)
20668 
      iprot.readFieldEnd()
20669 
    iprot.readStructEnd()
20670 
 
20671 
  def write(self, oprot):
20672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20674 
      return
20675 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
20676 
    if self.success is not None:
20677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20678 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20679 
      for iter466 in self.success:
20680 
        iter466.write(oprot)
4506 phani.kuma 20681 
      oprot.writeListEnd()
20682 
      oprot.writeFieldEnd()
20683 
    if self.ex is not None:
20684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20685 
      self.ex.write(oprot)
20686 
      oprot.writeFieldEnd()
20687 
    oprot.writeFieldStop()
20688 
    oprot.writeStructEnd()
20689 
 
20690 
  def validate(self):
20691 
    return
20692 
 
20693 
 
20694 
  def __repr__(self):
20695 
    L = ['%s=%r' % (key, value)
20696 
      for key, value in self.__dict__.iteritems()]
20697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20698 
 
20699 
  def __eq__(self, other):
20700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20701 
 
20702 
  def __ne__(self, other):
20703 
    return not (self == other)
4600 varun.gupt 20704 
 
20705 
class getBilledOrdersForVendor_args:
20706 
  """
20707 
  Attributes:
20708 
   - vendorId
20709 
   - billingDateFrom
20710 
   - billingDateTo
20711 
  """
20712 
 
20713 
  thrift_spec = (
20714 
    None, # 0
20715 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20716 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20717 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20718 
  )
20719 
 
20720 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20721 
    self.vendorId = vendorId
20722 
    self.billingDateFrom = billingDateFrom
20723 
    self.billingDateTo = billingDateTo
20724 
 
20725 
  def read(self, iprot):
20726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20728 
      return
20729 
    iprot.readStructBegin()
20730 
    while True:
20731 
      (fname, ftype, fid) = iprot.readFieldBegin()
20732 
      if ftype == TType.STOP:
20733 
        break
20734 
      if fid == 1:
20735 
        if ftype == TType.I64:
20736 
          self.vendorId = iprot.readI64();
20737 
        else:
20738 
          iprot.skip(ftype)
20739 
      elif fid == 2:
20740 
        if ftype == TType.I64:
20741 
          self.billingDateFrom = iprot.readI64();
20742 
        else:
20743 
          iprot.skip(ftype)
20744 
      elif fid == 3:
20745 
        if ftype == TType.I64:
20746 
          self.billingDateTo = iprot.readI64();
20747 
        else:
20748 
          iprot.skip(ftype)
20749 
      else:
20750 
        iprot.skip(ftype)
20751 
      iprot.readFieldEnd()
20752 
    iprot.readStructEnd()
20753 
 
20754 
  def write(self, oprot):
20755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20757 
      return
20758 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20759 
    if self.vendorId is not None:
20760 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20761 
      oprot.writeI64(self.vendorId)
20762 
      oprot.writeFieldEnd()
20763 
    if self.billingDateFrom is not None:
20764 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20765 
      oprot.writeI64(self.billingDateFrom)
20766 
      oprot.writeFieldEnd()
20767 
    if self.billingDateTo is not None:
20768 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20769 
      oprot.writeI64(self.billingDateTo)
20770 
      oprot.writeFieldEnd()
20771 
    oprot.writeFieldStop()
20772 
    oprot.writeStructEnd()
20773 
 
20774 
  def validate(self):
20775 
    return
20776 
 
20777 
 
20778 
  def __repr__(self):
20779 
    L = ['%s=%r' % (key, value)
20780 
      for key, value in self.__dict__.iteritems()]
20781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20782 
 
20783 
  def __eq__(self, other):
20784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20785 
 
20786 
  def __ne__(self, other):
20787 
    return not (self == other)
20788 
 
20789 
class getBilledOrdersForVendor_result:
20790 
  """
20791 
  Attributes:
20792 
   - success
20793 
   - ex
20794 
  """
20795 
 
20796 
  thrift_spec = (
20797 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20799 
  )
20800 
 
20801 
  def __init__(self, success=None, ex=None,):
20802 
    self.success = success
20803 
    self.ex = ex
20804 
 
20805 
  def read(self, iprot):
20806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20808 
      return
20809 
    iprot.readStructBegin()
20810 
    while True:
20811 
      (fname, ftype, fid) = iprot.readFieldBegin()
20812 
      if ftype == TType.STOP:
20813 
        break
20814 
      if fid == 0:
20815 
        if ftype == TType.LIST:
20816 
          self.success = []
5481 phani.kuma 20817 
          (_etype470, _size467) = iprot.readListBegin()
20818 
          for _i471 in xrange(_size467):
20819 
            _elem472 = Order()
20820 
            _elem472.read(iprot)
20821 
            self.success.append(_elem472)
4600 varun.gupt 20822 
          iprot.readListEnd()
20823 
        else:
20824 
          iprot.skip(ftype)
20825 
      elif fid == 1:
20826 
        if ftype == TType.STRUCT:
20827 
          self.ex = TransactionServiceException()
20828 
          self.ex.read(iprot)
20829 
        else:
20830 
          iprot.skip(ftype)
20831 
      else:
20832 
        iprot.skip(ftype)
20833 
      iprot.readFieldEnd()
20834 
    iprot.readStructEnd()
20835 
 
20836 
  def write(self, oprot):
20837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20839 
      return
20840 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20841 
    if self.success is not None:
20842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20843 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20844 
      for iter473 in self.success:
20845 
        iter473.write(oprot)
4600 varun.gupt 20846 
      oprot.writeListEnd()
20847 
      oprot.writeFieldEnd()
20848 
    if self.ex is not None:
20849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20850 
      self.ex.write(oprot)
20851 
      oprot.writeFieldEnd()
20852 
    oprot.writeFieldStop()
20853 
    oprot.writeStructEnd()
20854 
 
20855 
  def validate(self):
20856 
    return
20857 
 
20858 
 
20859 
  def __repr__(self):
20860 
    L = ['%s=%r' % (key, value)
20861 
      for key, value in self.__dict__.iteritems()]
20862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20863 
 
20864 
  def __eq__(self, other):
20865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20866 
 
20867 
  def __ne__(self, other):
20868 
    return not (self == other)
20869 
 
4607 rajveer 20870 
class getSlippedSippingDateOrders_args:
20871 
 
20872 
  thrift_spec = (
20873 
  )
20874 
 
20875 
  def read(self, iprot):
20876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20878 
      return
20879 
    iprot.readStructBegin()
20880 
    while True:
20881 
      (fname, ftype, fid) = iprot.readFieldBegin()
20882 
      if ftype == TType.STOP:
20883 
        break
20884 
      else:
20885 
        iprot.skip(ftype)
20886 
      iprot.readFieldEnd()
20887 
    iprot.readStructEnd()
20888 
 
20889 
  def write(self, oprot):
20890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20892 
      return
20893 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20894 
    oprot.writeFieldStop()
20895 
    oprot.writeStructEnd()
20896 
 
20897 
  def validate(self):
20898 
    return
20899 
 
20900 
 
20901 
  def __repr__(self):
20902 
    L = ['%s=%r' % (key, value)
20903 
      for key, value in self.__dict__.iteritems()]
20904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20905 
 
20906 
  def __eq__(self, other):
20907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20908 
 
20909 
  def __ne__(self, other):
20910 
    return not (self == other)
20911 
 
20912 
class getSlippedSippingDateOrders_result:
20913 
  """
20914 
  Attributes:
20915 
   - success
20916 
   - ex
20917 
  """
20918 
 
20919 
  thrift_spec = (
20920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20922 
  )
20923 
 
20924 
  def __init__(self, success=None, ex=None,):
20925 
    self.success = success
20926 
    self.ex = ex
20927 
 
20928 
  def read(self, iprot):
20929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20931 
      return
20932 
    iprot.readStructBegin()
20933 
    while True:
20934 
      (fname, ftype, fid) = iprot.readFieldBegin()
20935 
      if ftype == TType.STOP:
20936 
        break
20937 
      if fid == 0:
20938 
        if ftype == TType.LIST:
20939 
          self.success = []
5481 phani.kuma 20940 
          (_etype477, _size474) = iprot.readListBegin()
20941 
          for _i478 in xrange(_size474):
20942 
            _elem479 = Order()
20943 
            _elem479.read(iprot)
20944 
            self.success.append(_elem479)
4607 rajveer 20945 
          iprot.readListEnd()
20946 
        else:
20947 
          iprot.skip(ftype)
20948 
      elif fid == 1:
20949 
        if ftype == TType.STRUCT:
20950 
          self.ex = TransactionServiceException()
20951 
          self.ex.read(iprot)
20952 
        else:
20953 
          iprot.skip(ftype)
20954 
      else:
20955 
        iprot.skip(ftype)
20956 
      iprot.readFieldEnd()
20957 
    iprot.readStructEnd()
20958 
 
20959 
  def write(self, oprot):
20960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20962 
      return
20963 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20964 
    if self.success is not None:
20965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20967 
      for iter480 in self.success:
20968 
        iter480.write(oprot)
4607 rajveer 20969 
      oprot.writeListEnd()
20970 
      oprot.writeFieldEnd()
20971 
    if self.ex is not None:
20972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20973 
      self.ex.write(oprot)
20974 
      oprot.writeFieldEnd()
20975 
    oprot.writeFieldStop()
20976 
    oprot.writeStructEnd()
20977 
 
20978 
  def validate(self):
20979 
    return
20980 
 
20981 
 
20982 
  def __repr__(self):
20983 
    L = ['%s=%r' % (key, value)
20984 
      for key, value in self.__dict__.iteritems()]
20985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20986 
 
20987 
  def __eq__(self, other):
20988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20989 
 
20990 
  def __ne__(self, other):
20991 
    return not (self == other)
20992 
 
4709 rajveer 20993 
class getCancelledOrders_args:
20994 
  """
20995 
  Attributes:
20996 
   - cancelDateFrom
20997 
   - cancelDateTo
20998 
  """
20999 
 
21000 
  thrift_spec = (
21001 
    None, # 0
21002 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21003 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21004 
  )
21005 
 
21006 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21007 
    self.cancelDateFrom = cancelDateFrom
21008 
    self.cancelDateTo = cancelDateTo
21009 
 
21010 
  def read(self, iprot):
21011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21013 
      return
21014 
    iprot.readStructBegin()
21015 
    while True:
21016 
      (fname, ftype, fid) = iprot.readFieldBegin()
21017 
      if ftype == TType.STOP:
21018 
        break
21019 
      if fid == 1:
21020 
        if ftype == TType.I64:
21021 
          self.cancelDateFrom = iprot.readI64();
21022 
        else:
21023 
          iprot.skip(ftype)
21024 
      elif fid == 2:
21025 
        if ftype == TType.I64:
21026 
          self.cancelDateTo = iprot.readI64();
21027 
        else:
21028 
          iprot.skip(ftype)
21029 
      else:
21030 
        iprot.skip(ftype)
21031 
      iprot.readFieldEnd()
21032 
    iprot.readStructEnd()
21033 
 
21034 
  def write(self, oprot):
21035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21037 
      return
21038 
    oprot.writeStructBegin('getCancelledOrders_args')
21039 
    if self.cancelDateFrom is not None:
21040 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21041 
      oprot.writeI64(self.cancelDateFrom)
21042 
      oprot.writeFieldEnd()
21043 
    if self.cancelDateTo is not None:
21044 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21045 
      oprot.writeI64(self.cancelDateTo)
21046 
      oprot.writeFieldEnd()
21047 
    oprot.writeFieldStop()
21048 
    oprot.writeStructEnd()
21049 
 
21050 
  def validate(self):
21051 
    return
21052 
 
21053 
 
21054 
  def __repr__(self):
21055 
    L = ['%s=%r' % (key, value)
21056 
      for key, value in self.__dict__.iteritems()]
21057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21058 
 
21059 
  def __eq__(self, other):
21060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21061 
 
21062 
  def __ne__(self, other):
21063 
    return not (self == other)
21064 
 
21065 
class getCancelledOrders_result:
21066 
  """
21067 
  Attributes:
21068 
   - success
21069 
   - ex
21070 
  """
21071 
 
21072 
  thrift_spec = (
21073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21075 
  )
21076 
 
21077 
  def __init__(self, success=None, ex=None,):
21078 
    self.success = success
21079 
    self.ex = ex
21080 
 
21081 
  def read(self, iprot):
21082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21084 
      return
21085 
    iprot.readStructBegin()
21086 
    while True:
21087 
      (fname, ftype, fid) = iprot.readFieldBegin()
21088 
      if ftype == TType.STOP:
21089 
        break
21090 
      if fid == 0:
21091 
        if ftype == TType.LIST:
21092 
          self.success = []
5481 phani.kuma 21093 
          (_etype484, _size481) = iprot.readListBegin()
21094 
          for _i485 in xrange(_size481):
21095 
            _elem486 = Order()
21096 
            _elem486.read(iprot)
21097 
            self.success.append(_elem486)
4709 rajveer 21098 
          iprot.readListEnd()
21099 
        else:
21100 
          iprot.skip(ftype)
21101 
      elif fid == 1:
21102 
        if ftype == TType.STRUCT:
21103 
          self.ex = TransactionServiceException()
21104 
          self.ex.read(iprot)
21105 
        else:
21106 
          iprot.skip(ftype)
21107 
      else:
21108 
        iprot.skip(ftype)
21109 
      iprot.readFieldEnd()
21110 
    iprot.readStructEnd()
21111 
 
21112 
  def write(self, oprot):
21113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21115 
      return
21116 
    oprot.writeStructBegin('getCancelledOrders_result')
21117 
    if self.success is not None:
21118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 21120 
      for iter487 in self.success:
21121 
        iter487.write(oprot)
4709 rajveer 21122 
      oprot.writeListEnd()
21123 
      oprot.writeFieldEnd()
21124 
    if self.ex is not None:
21125 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21126 
      self.ex.write(oprot)
21127 
      oprot.writeFieldEnd()
21128 
    oprot.writeFieldStop()
21129 
    oprot.writeStructEnd()
21130 
 
21131 
  def validate(self):
21132 
    return
21133 
 
21134 
 
21135 
  def __repr__(self):
21136 
    L = ['%s=%r' % (key, value)
21137 
      for key, value in self.__dict__.iteritems()]
21138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21139 
 
21140 
  def __eq__(self, other):
21141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21142 
 
21143 
  def __ne__(self, other):
21144 
    return not (self == other)
21145 
 
4600 varun.gupt 21146 
class saveBluedartSettlements_args:
21147 
  """
21148 
  Attributes:
21149 
   - mapAWBAndAmount
21150 
  """
21151 
 
21152 
  thrift_spec = (
21153 
    None, # 0
21154 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21155 
  )
21156 
 
21157 
  def __init__(self, mapAWBAndAmount=None,):
21158 
    self.mapAWBAndAmount = mapAWBAndAmount
21159 
 
21160 
  def read(self, iprot):
21161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21163 
      return
21164 
    iprot.readStructBegin()
21165 
    while True:
21166 
      (fname, ftype, fid) = iprot.readFieldBegin()
21167 
      if ftype == TType.STOP:
21168 
        break
21169 
      if fid == 1:
21170 
        if ftype == TType.MAP:
21171 
          self.mapAWBAndAmount = {}
5481 phani.kuma 21172 
          (_ktype489, _vtype490, _size488 ) = iprot.readMapBegin()
21173 
          for _i492 in xrange(_size488):
21174 
            _key493 = iprot.readI64();
21175 
            _val494 = iprot.readDouble();
21176 
            self.mapAWBAndAmount[_key493] = _val494
4600 varun.gupt 21177 
          iprot.readMapEnd()
21178 
        else:
21179 
          iprot.skip(ftype)
21180 
      else:
21181 
        iprot.skip(ftype)
21182 
      iprot.readFieldEnd()
21183 
    iprot.readStructEnd()
21184 
 
21185 
  def write(self, oprot):
21186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21188 
      return
21189 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21190 
    if self.mapAWBAndAmount is not None:
21191 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21192 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5481 phani.kuma 21193 
      for kiter495,viter496 in self.mapAWBAndAmount.items():
21194 
        oprot.writeI64(kiter495)
21195 
        oprot.writeDouble(viter496)
4600 varun.gupt 21196 
      oprot.writeMapEnd()
21197 
      oprot.writeFieldEnd()
21198 
    oprot.writeFieldStop()
21199 
    oprot.writeStructEnd()
21200 
 
21201 
  def validate(self):
21202 
    return
21203 
 
21204 
 
21205 
  def __repr__(self):
21206 
    L = ['%s=%r' % (key, value)
21207 
      for key, value in self.__dict__.iteritems()]
21208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21209 
 
21210 
  def __eq__(self, other):
21211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21212 
 
21213 
  def __ne__(self, other):
21214 
    return not (self == other)
21215 
 
21216 
class saveBluedartSettlements_result:
21217 
  """
21218 
  Attributes:
21219 
   - ex
21220 
  """
21221 
 
21222 
  thrift_spec = (
21223 
    None, # 0
21224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21225 
  )
21226 
 
21227 
  def __init__(self, ex=None,):
21228 
    self.ex = ex
21229 
 
21230 
  def read(self, iprot):
21231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21233 
      return
21234 
    iprot.readStructBegin()
21235 
    while True:
21236 
      (fname, ftype, fid) = iprot.readFieldBegin()
21237 
      if ftype == TType.STOP:
21238 
        break
21239 
      if 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('saveBluedartSettlements_result')
21255 
    if self.ex is not None:
21256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21257 
      self.ex.write(oprot)
21258 
      oprot.writeFieldEnd()
21259 
    oprot.writeFieldStop()
21260 
    oprot.writeStructEnd()
21261 
 
21262 
  def validate(self):
21263 
    return
21264 
 
21265 
 
21266 
  def __repr__(self):
21267 
    L = ['%s=%r' % (key, value)
21268 
      for key, value in self.__dict__.iteritems()]
21269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21270 
 
21271 
  def __eq__(self, other):
21272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21273 
 
21274 
  def __ne__(self, other):
21275 
    return not (self == other)
21276 
 
21277 
class savePaymentSettlements_args:
21278 
  """
21279 
  Attributes:
21280 
   - settlementDate
21281 
   - paymentGatewayId
4905 varun.gupt 21282 
   - referenceId
4600 varun.gupt 21283 
   - serviceTax
21284 
   - otherCharges
21285 
   - netCollection
21286 
  """
21287 
 
21288 
  thrift_spec = (
21289 
    None, # 0
21290 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21291 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21292 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21293 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21294 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21295 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21296 
  )
21297 
 
4905 varun.gupt 21298 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21299 
    self.settlementDate = settlementDate
21300 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21301 
    self.referenceId = referenceId
4600 varun.gupt 21302 
    self.serviceTax = serviceTax
21303 
    self.otherCharges = otherCharges
21304 
    self.netCollection = netCollection
21305 
 
21306 
  def read(self, iprot):
21307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21309 
      return
21310 
    iprot.readStructBegin()
21311 
    while True:
21312 
      (fname, ftype, fid) = iprot.readFieldBegin()
21313 
      if ftype == TType.STOP:
21314 
        break
21315 
      if fid == 1:
21316 
        if ftype == TType.I64:
21317 
          self.settlementDate = iprot.readI64();
21318 
        else:
21319 
          iprot.skip(ftype)
21320 
      elif fid == 2:
21321 
        if ftype == TType.I64:
21322 
          self.paymentGatewayId = iprot.readI64();
21323 
        else:
21324 
          iprot.skip(ftype)
21325 
      elif fid == 3:
21326 
        if ftype == TType.I64:
4905 varun.gupt 21327 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21328 
        else:
21329 
          iprot.skip(ftype)
21330 
      elif fid == 4:
21331 
        if ftype == TType.DOUBLE:
21332 
          self.serviceTax = iprot.readDouble();
21333 
        else:
21334 
          iprot.skip(ftype)
21335 
      elif fid == 5:
21336 
        if ftype == TType.DOUBLE:
21337 
          self.otherCharges = iprot.readDouble();
21338 
        else:
21339 
          iprot.skip(ftype)
21340 
      elif fid == 6:
21341 
        if ftype == TType.DOUBLE:
21342 
          self.netCollection = iprot.readDouble();
21343 
        else:
21344 
          iprot.skip(ftype)
21345 
      else:
21346 
        iprot.skip(ftype)
21347 
      iprot.readFieldEnd()
21348 
    iprot.readStructEnd()
21349 
 
21350 
  def write(self, oprot):
21351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21353 
      return
21354 
    oprot.writeStructBegin('savePaymentSettlements_args')
21355 
    if self.settlementDate is not None:
21356 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21357 
      oprot.writeI64(self.settlementDate)
21358 
      oprot.writeFieldEnd()
21359 
    if self.paymentGatewayId is not None:
21360 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21361 
      oprot.writeI64(self.paymentGatewayId)
21362 
      oprot.writeFieldEnd()
4905 varun.gupt 21363 
    if self.referenceId is not None:
21364 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21365 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21366 
      oprot.writeFieldEnd()
21367 
    if self.serviceTax is not None:
21368 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21369 
      oprot.writeDouble(self.serviceTax)
21370 
      oprot.writeFieldEnd()
21371 
    if self.otherCharges is not None:
21372 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21373 
      oprot.writeDouble(self.otherCharges)
21374 
      oprot.writeFieldEnd()
21375 
    if self.netCollection is not None:
21376 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21377 
      oprot.writeDouble(self.netCollection)
21378 
      oprot.writeFieldEnd()
21379 
    oprot.writeFieldStop()
21380 
    oprot.writeStructEnd()
21381 
 
21382 
  def validate(self):
21383 
    return
21384 
 
21385 
 
21386 
  def __repr__(self):
21387 
    L = ['%s=%r' % (key, value)
21388 
      for key, value in self.__dict__.iteritems()]
21389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21390 
 
21391 
  def __eq__(self, other):
21392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21393 
 
21394 
  def __ne__(self, other):
21395 
    return not (self == other)
21396 
 
21397 
class savePaymentSettlements_result:
21398 
  """
21399 
  Attributes:
21400 
   - ex
21401 
  """
21402 
 
21403 
  thrift_spec = (
21404 
    None, # 0
21405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21406 
  )
21407 
 
21408 
  def __init__(self, ex=None,):
21409 
    self.ex = ex
21410 
 
21411 
  def read(self, iprot):
21412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21414 
      return
21415 
    iprot.readStructBegin()
21416 
    while True:
21417 
      (fname, ftype, fid) = iprot.readFieldBegin()
21418 
      if ftype == TType.STOP:
21419 
        break
21420 
      if fid == 1:
21421 
        if ftype == TType.STRUCT:
21422 
          self.ex = TransactionServiceException()
21423 
          self.ex.read(iprot)
21424 
        else:
21425 
          iprot.skip(ftype)
21426 
      else:
21427 
        iprot.skip(ftype)
21428 
      iprot.readFieldEnd()
21429 
    iprot.readStructEnd()
21430 
 
21431 
  def write(self, oprot):
21432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21434 
      return
21435 
    oprot.writeStructBegin('savePaymentSettlements_result')
21436 
    if self.ex is not None:
21437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21438 
      self.ex.write(oprot)
21439 
      oprot.writeFieldEnd()
21440 
    oprot.writeFieldStop()
21441 
    oprot.writeStructEnd()
21442 
 
21443 
  def validate(self):
21444 
    return
21445 
 
21446 
 
21447 
  def __repr__(self):
21448 
    L = ['%s=%r' % (key, value)
21449 
      for key, value in self.__dict__.iteritems()]
21450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21451 
 
21452 
  def __eq__(self, other):
21453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21454 
 
21455 
  def __ne__(self, other):
21456 
    return not (self == other)
21457 
 
21458 
class saveEBSSettlementSummary_args:
21459 
  """
21460 
  Attributes:
21461 
   - settlementId
21462 
   - settlementDate
21463 
   - transactionDateFrom
21464 
   - transactionDateTo
21465 
   - amount
21466 
  """
21467 
 
21468 
  thrift_spec = (
21469 
    None, # 0
21470 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21471 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21472 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21473 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21474 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21475 
  )
21476 
 
21477 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21478 
    self.settlementId = settlementId
21479 
    self.settlementDate = settlementDate
21480 
    self.transactionDateFrom = transactionDateFrom
21481 
    self.transactionDateTo = transactionDateTo
21482 
    self.amount = amount
21483 
 
21484 
  def read(self, iprot):
21485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21487 
      return
21488 
    iprot.readStructBegin()
21489 
    while True:
21490 
      (fname, ftype, fid) = iprot.readFieldBegin()
21491 
      if ftype == TType.STOP:
21492 
        break
21493 
      if fid == 1:
21494 
        if ftype == TType.I64:
21495 
          self.settlementId = iprot.readI64();
21496 
        else:
21497 
          iprot.skip(ftype)
21498 
      elif fid == 2:
21499 
        if ftype == TType.I64:
21500 
          self.settlementDate = iprot.readI64();
21501 
        else:
21502 
          iprot.skip(ftype)
21503 
      elif fid == 3:
21504 
        if ftype == TType.I64:
21505 
          self.transactionDateFrom = iprot.readI64();
21506 
        else:
21507 
          iprot.skip(ftype)
21508 
      elif fid == 4:
21509 
        if ftype == TType.I64:
21510 
          self.transactionDateTo = iprot.readI64();
21511 
        else:
21512 
          iprot.skip(ftype)
21513 
      elif fid == 5:
21514 
        if ftype == TType.DOUBLE:
21515 
          self.amount = iprot.readDouble();
21516 
        else:
21517 
          iprot.skip(ftype)
21518 
      else:
21519 
        iprot.skip(ftype)
21520 
      iprot.readFieldEnd()
21521 
    iprot.readStructEnd()
21522 
 
21523 
  def write(self, oprot):
21524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21526 
      return
21527 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21528 
    if self.settlementId is not None:
21529 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21530 
      oprot.writeI64(self.settlementId)
21531 
      oprot.writeFieldEnd()
21532 
    if self.settlementDate is not None:
21533 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21534 
      oprot.writeI64(self.settlementDate)
21535 
      oprot.writeFieldEnd()
21536 
    if self.transactionDateFrom is not None:
21537 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21538 
      oprot.writeI64(self.transactionDateFrom)
21539 
      oprot.writeFieldEnd()
21540 
    if self.transactionDateTo is not None:
21541 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21542 
      oprot.writeI64(self.transactionDateTo)
21543 
      oprot.writeFieldEnd()
21544 
    if self.amount is not None:
21545 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21546 
      oprot.writeDouble(self.amount)
21547 
      oprot.writeFieldEnd()
21548 
    oprot.writeFieldStop()
21549 
    oprot.writeStructEnd()
21550 
 
21551 
  def validate(self):
21552 
    return
21553 
 
21554 
 
21555 
  def __repr__(self):
21556 
    L = ['%s=%r' % (key, value)
21557 
      for key, value in self.__dict__.iteritems()]
21558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21559 
 
21560 
  def __eq__(self, other):
21561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21562 
 
21563 
  def __ne__(self, other):
21564 
    return not (self == other)
21565 
 
21566 
class saveEBSSettlementSummary_result:
21567 
  """
21568 
  Attributes:
21569 
   - ex
21570 
  """
21571 
 
21572 
  thrift_spec = (
21573 
    None, # 0
21574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21575 
  )
21576 
 
21577 
  def __init__(self, ex=None,):
21578 
    self.ex = ex
21579 
 
21580 
  def read(self, iprot):
21581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21583 
      return
21584 
    iprot.readStructBegin()
21585 
    while True:
21586 
      (fname, ftype, fid) = iprot.readFieldBegin()
21587 
      if ftype == TType.STOP:
21588 
        break
21589 
      if fid == 1:
21590 
        if ftype == TType.STRUCT:
21591 
          self.ex = TransactionServiceException()
21592 
          self.ex.read(iprot)
21593 
        else:
21594 
          iprot.skip(ftype)
21595 
      else:
21596 
        iprot.skip(ftype)
21597 
      iprot.readFieldEnd()
21598 
    iprot.readStructEnd()
21599 
 
21600 
  def write(self, oprot):
21601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21603 
      return
21604 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
21605 
    if self.ex is not None:
21606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21607 
      self.ex.write(oprot)
21608 
      oprot.writeFieldEnd()
21609 
    oprot.writeFieldStop()
21610 
    oprot.writeStructEnd()
21611 
 
21612 
  def validate(self):
21613 
    return
21614 
 
21615 
 
21616 
  def __repr__(self):
21617 
    L = ['%s=%r' % (key, value)
21618 
      for key, value in self.__dict__.iteritems()]
21619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21620 
 
21621 
  def __eq__(self, other):
21622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21623 
 
21624 
  def __ne__(self, other):
21625 
    return not (self == other)
21626 
 
5386 phani.kuma 21627 
class getSettlementForPrepaid_args:
4600 varun.gupt 21628 
  """
21629 
  Attributes:
5189 varun.gupt 21630 
   - referenceId
21631 
   - isRefund
4600 varun.gupt 21632 
  """
21633 
 
21634 
  thrift_spec = (
21635 
    None, # 0
5189 varun.gupt 21636 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21637 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21638 
  )
21639 
 
5386 phani.kuma 21640 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21641 
    self.referenceId = referenceId
21642 
    self.isRefund = isRefund
4600 varun.gupt 21643 
 
21644 
  def read(self, iprot):
21645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21647 
      return
21648 
    iprot.readStructBegin()
21649 
    while True:
21650 
      (fname, ftype, fid) = iprot.readFieldBegin()
21651 
      if ftype == TType.STOP:
21652 
        break
21653 
      if fid == 1:
21654 
        if ftype == TType.I64:
5189 varun.gupt 21655 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21656 
        else:
21657 
          iprot.skip(ftype)
5189 varun.gupt 21658 
      elif fid == 2:
21659 
        if ftype == TType.BOOL:
21660 
          self.isRefund = iprot.readBool();
21661 
        else:
21662 
          iprot.skip(ftype)
4600 varun.gupt 21663 
      else:
21664 
        iprot.skip(ftype)
21665 
      iprot.readFieldEnd()
21666 
    iprot.readStructEnd()
21667 
 
21668 
  def write(self, oprot):
21669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21671 
      return
5386 phani.kuma 21672 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21673 
    if self.referenceId is not None:
21674 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
21675 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21676 
      oprot.writeFieldEnd()
5386 phani.kuma 21677 
    if self.isRefund is not None:
21678 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
21679 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 21680 
      oprot.writeFieldEnd()
5386 phani.kuma 21681 
    oprot.writeFieldStop()
21682 
    oprot.writeStructEnd()
21683 
 
21684 
  def validate(self):
21685 
    return
21686 
 
21687 
 
21688 
  def __repr__(self):
21689 
    L = ['%s=%r' % (key, value)
21690 
      for key, value in self.__dict__.iteritems()]
21691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21692 
 
21693 
  def __eq__(self, other):
21694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21695 
 
21696 
  def __ne__(self, other):
21697 
    return not (self == other)
21698 
 
21699 
class getSettlementForPrepaid_result:
21700 
  """
21701 
  Attributes:
21702 
   - success
21703 
   - ex
21704 
  """
21705 
 
21706 
  thrift_spec = (
21707 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21709 
  )
21710 
 
21711 
  def __init__(self, success=None, ex=None,):
21712 
    self.success = success
21713 
    self.ex = ex
21714 
 
21715 
  def read(self, iprot):
21716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21718 
      return
21719 
    iprot.readStructBegin()
21720 
    while True:
21721 
      (fname, ftype, fid) = iprot.readFieldBegin()
21722 
      if ftype == TType.STOP:
21723 
        break
21724 
      if fid == 0:
21725 
        if ftype == TType.STRUCT:
21726 
          self.success = PaymentSettlement()
21727 
          self.success.read(iprot)
21728 
        else:
21729 
          iprot.skip(ftype)
21730 
      elif fid == 1:
21731 
        if ftype == TType.STRUCT:
21732 
          self.ex = TransactionServiceException()
21733 
          self.ex.read(iprot)
21734 
        else:
21735 
          iprot.skip(ftype)
21736 
      else:
21737 
        iprot.skip(ftype)
21738 
      iprot.readFieldEnd()
21739 
    iprot.readStructEnd()
21740 
 
21741 
  def write(self, oprot):
21742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21744 
      return
21745 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21746 
    if self.success is not None:
21747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21748 
      self.success.write(oprot)
21749 
      oprot.writeFieldEnd()
21750 
    if self.ex is not None:
21751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21752 
      self.ex.write(oprot)
21753 
      oprot.writeFieldEnd()
21754 
    oprot.writeFieldStop()
21755 
    oprot.writeStructEnd()
21756 
 
21757 
  def validate(self):
21758 
    return
21759 
 
21760 
 
21761 
  def __repr__(self):
21762 
    L = ['%s=%r' % (key, value)
21763 
      for key, value in self.__dict__.iteritems()]
21764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21765 
 
21766 
  def __eq__(self, other):
21767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21768 
 
21769 
  def __ne__(self, other):
21770 
    return not (self == other)
21771 
 
21772 
class getSettlementForCod_args:
21773 
  """
21774 
  Attributes:
21775 
   - orderId
21776 
   - isRefund
21777 
  """
21778 
 
21779 
  thrift_spec = (
21780 
    None, # 0
21781 
    (1, TType.I64, 'orderId', None, None, ), # 1
21782 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21783 
  )
21784 
 
21785 
  def __init__(self, orderId=None, isRefund=None,):
21786 
    self.orderId = orderId
21787 
    self.isRefund = isRefund
21788 
 
21789 
  def read(self, iprot):
21790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21792 
      return
21793 
    iprot.readStructBegin()
21794 
    while True:
21795 
      (fname, ftype, fid) = iprot.readFieldBegin()
21796 
      if ftype == TType.STOP:
21797 
        break
21798 
      if fid == 1:
21799 
        if ftype == TType.I64:
21800 
          self.orderId = iprot.readI64();
21801 
        else:
21802 
          iprot.skip(ftype)
21803 
      elif fid == 2:
21804 
        if ftype == TType.BOOL:
21805 
          self.isRefund = iprot.readBool();
21806 
        else:
21807 
          iprot.skip(ftype)
21808 
      else:
21809 
        iprot.skip(ftype)
21810 
      iprot.readFieldEnd()
21811 
    iprot.readStructEnd()
21812 
 
21813 
  def write(self, oprot):
21814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21816 
      return
21817 
    oprot.writeStructBegin('getSettlementForCod_args')
21818 
    if self.orderId is not None:
21819 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21820 
      oprot.writeI64(self.orderId)
21821 
      oprot.writeFieldEnd()
5189 varun.gupt 21822 
    if self.isRefund is not None:
5386 phani.kuma 21823 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21824 
      oprot.writeBool(self.isRefund)
21825 
      oprot.writeFieldEnd()
4600 varun.gupt 21826 
    oprot.writeFieldStop()
21827 
    oprot.writeStructEnd()
21828 
 
21829 
  def validate(self):
21830 
    return
21831 
 
21832 
 
21833 
  def __repr__(self):
21834 
    L = ['%s=%r' % (key, value)
21835 
      for key, value in self.__dict__.iteritems()]
21836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21837 
 
21838 
  def __eq__(self, other):
21839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21840 
 
21841 
  def __ne__(self, other):
21842 
    return not (self == other)
21843 
 
5386 phani.kuma 21844 
class getSettlementForCod_result:
4600 varun.gupt 21845 
  """
21846 
  Attributes:
21847 
   - success
21848 
   - ex
21849 
  """
21850 
 
21851 
  thrift_spec = (
21852 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21854 
  )
21855 
 
21856 
  def __init__(self, success=None, ex=None,):
21857 
    self.success = success
21858 
    self.ex = ex
21859 
 
21860 
  def read(self, iprot):
21861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21863 
      return
21864 
    iprot.readStructBegin()
21865 
    while True:
21866 
      (fname, ftype, fid) = iprot.readFieldBegin()
21867 
      if ftype == TType.STOP:
21868 
        break
21869 
      if fid == 0:
21870 
        if ftype == TType.STRUCT:
21871 
          self.success = PaymentSettlement()
21872 
          self.success.read(iprot)
21873 
        else:
21874 
          iprot.skip(ftype)
21875 
      elif fid == 1:
21876 
        if ftype == TType.STRUCT:
21877 
          self.ex = TransactionServiceException()
21878 
          self.ex.read(iprot)
21879 
        else:
21880 
          iprot.skip(ftype)
21881 
      else:
21882 
        iprot.skip(ftype)
21883 
      iprot.readFieldEnd()
21884 
    iprot.readStructEnd()
21885 
 
21886 
  def write(self, oprot):
21887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21889 
      return
5386 phani.kuma 21890 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21891 
    if self.success is not None:
21892 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21893 
      self.success.write(oprot)
21894 
      oprot.writeFieldEnd()
21895 
    if self.ex is not None:
21896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21897 
      self.ex.write(oprot)
21898 
      oprot.writeFieldEnd()
21899 
    oprot.writeFieldStop()
21900 
    oprot.writeStructEnd()
21901 
 
21902 
  def validate(self):
21903 
    return
21904 
 
21905 
 
21906 
  def __repr__(self):
21907 
    L = ['%s=%r' % (key, value)
21908 
      for key, value in self.__dict__.iteritems()]
21909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21910 
 
21911 
  def __eq__(self, other):
21912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21913 
 
21914 
  def __ne__(self, other):
21915 
    return not (self == other)
21916 
 
21917 
class getEBSSettlementSummaries_args:
21918 
 
21919 
  thrift_spec = (
21920 
  )
21921 
 
21922 
  def read(self, iprot):
21923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21925 
      return
21926 
    iprot.readStructBegin()
21927 
    while True:
21928 
      (fname, ftype, fid) = iprot.readFieldBegin()
21929 
      if ftype == TType.STOP:
21930 
        break
21931 
      else:
21932 
        iprot.skip(ftype)
21933 
      iprot.readFieldEnd()
21934 
    iprot.readStructEnd()
21935 
 
21936 
  def write(self, oprot):
21937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21939 
      return
21940 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21941 
    oprot.writeFieldStop()
21942 
    oprot.writeStructEnd()
21943 
 
21944 
  def validate(self):
21945 
    return
21946 
 
21947 
 
21948 
  def __repr__(self):
21949 
    L = ['%s=%r' % (key, value)
21950 
      for key, value in self.__dict__.iteritems()]
21951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21952 
 
21953 
  def __eq__(self, other):
21954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21955 
 
21956 
  def __ne__(self, other):
21957 
    return not (self == other)
21958 
 
21959 
class getEBSSettlementSummaries_result:
21960 
  """
21961 
  Attributes:
21962 
   - success
21963 
   - ex
21964 
  """
21965 
 
21966 
  thrift_spec = (
21967 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21969 
  )
21970 
 
21971 
  def __init__(self, success=None, ex=None,):
21972 
    self.success = success
21973 
    self.ex = ex
21974 
 
21975 
  def read(self, iprot):
21976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21978 
      return
21979 
    iprot.readStructBegin()
21980 
    while True:
21981 
      (fname, ftype, fid) = iprot.readFieldBegin()
21982 
      if ftype == TType.STOP:
21983 
        break
21984 
      if fid == 0:
21985 
        if ftype == TType.MAP:
21986 
          self.success = {}
5481 phani.kuma 21987 
          (_ktype498, _vtype499, _size497 ) = iprot.readMapBegin()
21988 
          for _i501 in xrange(_size497):
21989 
            _key502 = iprot.readI64();
21990 
            _val503 = iprot.readString();
21991 
            self.success[_key502] = _val503
4600 varun.gupt 21992 
          iprot.readMapEnd()
21993 
        else:
21994 
          iprot.skip(ftype)
21995 
      elif fid == 1:
21996 
        if ftype == TType.STRUCT:
21997 
          self.ex = TransactionServiceException()
21998 
          self.ex.read(iprot)
21999 
        else:
22000 
          iprot.skip(ftype)
22001 
      else:
22002 
        iprot.skip(ftype)
22003 
      iprot.readFieldEnd()
22004 
    iprot.readStructEnd()
22005 
 
22006 
  def write(self, oprot):
22007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22009 
      return
22010 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22011 
    if self.success is not None:
22012 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22013 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5481 phani.kuma 22014 
      for kiter504,viter505 in self.success.items():
22015 
        oprot.writeI64(kiter504)
22016 
        oprot.writeString(viter505)
4600 varun.gupt 22017 
      oprot.writeMapEnd()
22018 
      oprot.writeFieldEnd()
22019 
    if self.ex is not None:
22020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22021 
      self.ex.write(oprot)
22022 
      oprot.writeFieldEnd()
22023 
    oprot.writeFieldStop()
22024 
    oprot.writeStructEnd()
22025 
 
22026 
  def validate(self):
22027 
    return
22028 
 
22029 
 
22030 
  def __repr__(self):
22031 
    L = ['%s=%r' % (key, value)
22032 
      for key, value in self.__dict__.iteritems()]
22033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22034 
 
22035 
  def __eq__(self, other):
22036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22037 
 
22038 
  def __ne__(self, other):
22039 
    return not (self == other)
22040 
 
22041 
class markEBSSettlementUploaded_args:
22042 
  """
22043 
  Attributes:
22044 
   - settlementId
22045 
  """
22046 
 
22047 
  thrift_spec = (
22048 
    None, # 0
22049 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22050 
  )
22051 
 
22052 
  def __init__(self, settlementId=None,):
22053 
    self.settlementId = settlementId
22054 
 
22055 
  def read(self, iprot):
22056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22058 
      return
22059 
    iprot.readStructBegin()
22060 
    while True:
22061 
      (fname, ftype, fid) = iprot.readFieldBegin()
22062 
      if ftype == TType.STOP:
22063 
        break
22064 
      if fid == 1:
22065 
        if ftype == TType.I64:
22066 
          self.settlementId = iprot.readI64();
22067 
        else:
22068 
          iprot.skip(ftype)
22069 
      else:
22070 
        iprot.skip(ftype)
22071 
      iprot.readFieldEnd()
22072 
    iprot.readStructEnd()
22073 
 
22074 
  def write(self, oprot):
22075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22077 
      return
22078 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22079 
    if self.settlementId is not None:
22080 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22081 
      oprot.writeI64(self.settlementId)
22082 
      oprot.writeFieldEnd()
22083 
    oprot.writeFieldStop()
22084 
    oprot.writeStructEnd()
22085 
 
22086 
  def validate(self):
22087 
    return
22088 
 
22089 
 
22090 
  def __repr__(self):
22091 
    L = ['%s=%r' % (key, value)
22092 
      for key, value in self.__dict__.iteritems()]
22093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22094 
 
22095 
  def __eq__(self, other):
22096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22097 
 
22098 
  def __ne__(self, other):
22099 
    return not (self == other)
22100 
 
22101 
class markEBSSettlementUploaded_result:
22102 
  """
22103 
  Attributes:
22104 
   - ex
22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    None, # 0
22109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22110 
  )
22111 
 
22112 
  def __init__(self, ex=None,):
22113 
    self.ex = ex
22114 
 
22115 
  def read(self, iprot):
22116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22118 
      return
22119 
    iprot.readStructBegin()
22120 
    while True:
22121 
      (fname, ftype, fid) = iprot.readFieldBegin()
22122 
      if ftype == TType.STOP:
22123 
        break
22124 
      if fid == 1:
22125 
        if ftype == TType.STRUCT:
22126 
          self.ex = TransactionServiceException()
22127 
          self.ex.read(iprot)
22128 
        else:
22129 
          iprot.skip(ftype)
22130 
      else:
22131 
        iprot.skip(ftype)
22132 
      iprot.readFieldEnd()
22133 
    iprot.readStructEnd()
22134 
 
22135 
  def write(self, oprot):
22136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22138 
      return
22139 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22140 
    if self.ex is not None:
22141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22142 
      self.ex.write(oprot)
22143 
      oprot.writeFieldEnd()
22144 
    oprot.writeFieldStop()
22145 
    oprot.writeStructEnd()
22146 
 
22147 
  def validate(self):
22148 
    return
22149 
 
22150 
 
22151 
  def __repr__(self):
22152 
    L = ['%s=%r' % (key, value)
22153 
      for key, value in self.__dict__.iteritems()]
22154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22155 
 
22156 
  def __eq__(self, other):
22157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22158 
 
22159 
  def __ne__(self, other):
22160 
    return not (self == other)
22161 
 
22162 
class getEBSSettlementDate_args:
22163 
  """
22164 
  Attributes:
22165 
   - settlementId
22166 
  """
22167 
 
22168 
  thrift_spec = (
22169 
    None, # 0
22170 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22171 
  )
22172 
 
22173 
  def __init__(self, settlementId=None,):
22174 
    self.settlementId = settlementId
22175 
 
22176 
  def read(self, iprot):
22177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22179 
      return
22180 
    iprot.readStructBegin()
22181 
    while True:
22182 
      (fname, ftype, fid) = iprot.readFieldBegin()
22183 
      if ftype == TType.STOP:
22184 
        break
22185 
      if fid == 1:
22186 
        if ftype == TType.I64:
22187 
          self.settlementId = iprot.readI64();
22188 
        else:
22189 
          iprot.skip(ftype)
22190 
      else:
22191 
        iprot.skip(ftype)
22192 
      iprot.readFieldEnd()
22193 
    iprot.readStructEnd()
22194 
 
22195 
  def write(self, oprot):
22196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22198 
      return
22199 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22200 
    if self.settlementId is not None:
22201 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22202 
      oprot.writeI64(self.settlementId)
22203 
      oprot.writeFieldEnd()
22204 
    oprot.writeFieldStop()
22205 
    oprot.writeStructEnd()
22206 
 
22207 
  def validate(self):
22208 
    return
22209 
 
22210 
 
22211 
  def __repr__(self):
22212 
    L = ['%s=%r' % (key, value)
22213 
      for key, value in self.__dict__.iteritems()]
22214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22215 
 
22216 
  def __eq__(self, other):
22217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22218 
 
22219 
  def __ne__(self, other):
22220 
    return not (self == other)
22221 
 
22222 
class getEBSSettlementDate_result:
22223 
  """
22224 
  Attributes:
22225 
   - success
22226 
   - ex
22227 
  """
22228 
 
22229 
  thrift_spec = (
22230 
    (0, TType.I64, 'success', None, None, ), # 0
22231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22232 
  )
22233 
 
22234 
  def __init__(self, success=None, ex=None,):
22235 
    self.success = success
22236 
    self.ex = ex
22237 
 
22238 
  def read(self, iprot):
22239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22241 
      return
22242 
    iprot.readStructBegin()
22243 
    while True:
22244 
      (fname, ftype, fid) = iprot.readFieldBegin()
22245 
      if ftype == TType.STOP:
22246 
        break
22247 
      if fid == 0:
22248 
        if ftype == TType.I64:
22249 
          self.success = iprot.readI64();
22250 
        else:
22251 
          iprot.skip(ftype)
22252 
      elif fid == 1:
22253 
        if ftype == TType.STRUCT:
22254 
          self.ex = TransactionServiceException()
22255 
          self.ex.read(iprot)
22256 
        else:
22257 
          iprot.skip(ftype)
22258 
      else:
22259 
        iprot.skip(ftype)
22260 
      iprot.readFieldEnd()
22261 
    iprot.readStructEnd()
22262 
 
22263 
  def write(self, oprot):
22264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22266 
      return
22267 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22268 
    if self.success is not None:
22269 
      oprot.writeFieldBegin('success', TType.I64, 0)
22270 
      oprot.writeI64(self.success)
22271 
      oprot.writeFieldEnd()
22272 
    if self.ex is not None:
22273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22274 
      self.ex.write(oprot)
22275 
      oprot.writeFieldEnd()
22276 
    oprot.writeFieldStop()
22277 
    oprot.writeStructEnd()
22278 
 
22279 
  def validate(self):
22280 
    return
22281 
 
22282 
 
22283 
  def __repr__(self):
22284 
    L = ['%s=%r' % (key, value)
22285 
      for key, value in self.__dict__.iteritems()]
22286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22287 
 
22288 
  def __eq__(self, other):
22289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22290 
 
22291 
  def __ne__(self, other):
22292 
    return not (self == other)
4715 varun.gupt 22293 
 
22294 
class getSettlementsByDate_args:
22295 
  """
22296 
  Attributes:
22297 
   - settlementDateFrom
22298 
   - settlementDateTo
22299 
   - isRefund
22300 
  """
22301 
 
22302 
  thrift_spec = (
22303 
    None, # 0
22304 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22305 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22306 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22307 
  )
22308 
 
22309 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22310 
    self.settlementDateFrom = settlementDateFrom
22311 
    self.settlementDateTo = settlementDateTo
22312 
    self.isRefund = isRefund
22313 
 
22314 
  def read(self, iprot):
22315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22317 
      return
22318 
    iprot.readStructBegin()
22319 
    while True:
22320 
      (fname, ftype, fid) = iprot.readFieldBegin()
22321 
      if ftype == TType.STOP:
22322 
        break
22323 
      if fid == 1:
22324 
        if ftype == TType.I64:
22325 
          self.settlementDateFrom = iprot.readI64();
22326 
        else:
22327 
          iprot.skip(ftype)
22328 
      elif fid == 2:
22329 
        if ftype == TType.I64:
22330 
          self.settlementDateTo = iprot.readI64();
22331 
        else:
22332 
          iprot.skip(ftype)
22333 
      elif fid == 3:
22334 
        if ftype == TType.BOOL:
22335 
          self.isRefund = iprot.readBool();
22336 
        else:
22337 
          iprot.skip(ftype)
22338 
      else:
22339 
        iprot.skip(ftype)
22340 
      iprot.readFieldEnd()
22341 
    iprot.readStructEnd()
22342 
 
22343 
  def write(self, oprot):
22344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22346 
      return
22347 
    oprot.writeStructBegin('getSettlementsByDate_args')
22348 
    if self.settlementDateFrom is not None:
22349 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22350 
      oprot.writeI64(self.settlementDateFrom)
22351 
      oprot.writeFieldEnd()
22352 
    if self.settlementDateTo is not None:
22353 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22354 
      oprot.writeI64(self.settlementDateTo)
22355 
      oprot.writeFieldEnd()
22356 
    if self.isRefund is not None:
22357 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22358 
      oprot.writeBool(self.isRefund)
22359 
      oprot.writeFieldEnd()
22360 
    oprot.writeFieldStop()
22361 
    oprot.writeStructEnd()
22362 
 
22363 
  def validate(self):
22364 
    return
22365 
 
22366 
 
22367 
  def __repr__(self):
22368 
    L = ['%s=%r' % (key, value)
22369 
      for key, value in self.__dict__.iteritems()]
22370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22371 
 
22372 
  def __eq__(self, other):
22373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22374 
 
22375 
  def __ne__(self, other):
22376 
    return not (self == other)
22377 
 
22378 
class getSettlementsByDate_result:
22379 
  """
22380 
  Attributes:
22381 
   - success
22382 
   - ex
22383 
  """
22384 
 
22385 
  thrift_spec = (
22386 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22388 
  )
22389 
 
22390 
  def __init__(self, success=None, ex=None,):
22391 
    self.success = success
22392 
    self.ex = ex
22393 
 
22394 
  def read(self, iprot):
22395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22397 
      return
22398 
    iprot.readStructBegin()
22399 
    while True:
22400 
      (fname, ftype, fid) = iprot.readFieldBegin()
22401 
      if ftype == TType.STOP:
22402 
        break
22403 
      if fid == 0:
22404 
        if ftype == TType.LIST:
22405 
          self.success = []
5481 phani.kuma 22406 
          (_etype509, _size506) = iprot.readListBegin()
22407 
          for _i510 in xrange(_size506):
22408 
            _elem511 = PaymentSettlement()
22409 
            _elem511.read(iprot)
22410 
            self.success.append(_elem511)
4715 varun.gupt 22411 
          iprot.readListEnd()
22412 
        else:
22413 
          iprot.skip(ftype)
22414 
      elif fid == 1:
22415 
        if ftype == TType.STRUCT:
22416 
          self.ex = TransactionServiceException()
22417 
          self.ex.read(iprot)
22418 
        else:
22419 
          iprot.skip(ftype)
22420 
      else:
22421 
        iprot.skip(ftype)
22422 
      iprot.readFieldEnd()
22423 
    iprot.readStructEnd()
22424 
 
22425 
  def write(self, oprot):
22426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22428 
      return
22429 
    oprot.writeStructBegin('getSettlementsByDate_result')
22430 
    if self.success is not None:
22431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22433 
      for iter512 in self.success:
22434 
        iter512.write(oprot)
4715 varun.gupt 22435 
      oprot.writeListEnd()
22436 
      oprot.writeFieldEnd()
22437 
    if self.ex is not None:
22438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22439 
      self.ex.write(oprot)
22440 
      oprot.writeFieldEnd()
22441 
    oprot.writeFieldStop()
22442 
    oprot.writeStructEnd()
22443 
 
22444 
  def validate(self):
22445 
    return
22446 
 
22447 
 
22448 
  def __repr__(self):
22449 
    L = ['%s=%r' % (key, value)
22450 
      for key, value in self.__dict__.iteritems()]
22451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22452 
 
22453 
  def __eq__(self, other):
22454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22455 
 
22456 
  def __ne__(self, other):
22457 
    return not (self == other)
22458 
 
22459 
class getReshippedOrderIds_args:
22460 
  """
22461 
  Attributes:
22462 
   - orderIds
22463 
  """
22464 
 
22465 
  thrift_spec = (
22466 
    None, # 0
22467 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22468 
  )
22469 
 
22470 
  def __init__(self, orderIds=None,):
22471 
    self.orderIds = orderIds
22472 
 
22473 
  def read(self, iprot):
22474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22476 
      return
22477 
    iprot.readStructBegin()
22478 
    while True:
22479 
      (fname, ftype, fid) = iprot.readFieldBegin()
22480 
      if ftype == TType.STOP:
22481 
        break
22482 
      if fid == 1:
22483 
        if ftype == TType.LIST:
22484 
          self.orderIds = []
5481 phani.kuma 22485 
          (_etype516, _size513) = iprot.readListBegin()
22486 
          for _i517 in xrange(_size513):
22487 
            _elem518 = iprot.readI64();
22488 
            self.orderIds.append(_elem518)
4715 varun.gupt 22489 
          iprot.readListEnd()
22490 
        else:
22491 
          iprot.skip(ftype)
22492 
      else:
22493 
        iprot.skip(ftype)
22494 
      iprot.readFieldEnd()
22495 
    iprot.readStructEnd()
22496 
 
22497 
  def write(self, oprot):
22498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22500 
      return
22501 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22502 
    if self.orderIds is not None:
22503 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22504 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5481 phani.kuma 22505 
      for iter519 in self.orderIds:
22506 
        oprot.writeI64(iter519)
4715 varun.gupt 22507 
      oprot.writeListEnd()
22508 
      oprot.writeFieldEnd()
22509 
    oprot.writeFieldStop()
22510 
    oprot.writeStructEnd()
22511 
 
22512 
  def validate(self):
22513 
    return
22514 
 
22515 
 
22516 
  def __repr__(self):
22517 
    L = ['%s=%r' % (key, value)
22518 
      for key, value in self.__dict__.iteritems()]
22519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22520 
 
22521 
  def __eq__(self, other):
22522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22523 
 
22524 
  def __ne__(self, other):
22525 
    return not (self == other)
22526 
 
22527 
class getReshippedOrderIds_result:
22528 
  """
22529 
  Attributes:
22530 
   - success
22531 
   - ex
22532 
  """
22533 
 
22534 
  thrift_spec = (
22535 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22537 
  )
22538 
 
22539 
  def __init__(self, success=None, ex=None,):
22540 
    self.success = success
22541 
    self.ex = ex
22542 
 
22543 
  def read(self, iprot):
22544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22546 
      return
22547 
    iprot.readStructBegin()
22548 
    while True:
22549 
      (fname, ftype, fid) = iprot.readFieldBegin()
22550 
      if ftype == TType.STOP:
22551 
        break
22552 
      if fid == 0:
22553 
        if ftype == TType.LIST:
22554 
          self.success = []
5481 phani.kuma 22555 
          (_etype523, _size520) = iprot.readListBegin()
22556 
          for _i524 in xrange(_size520):
22557 
            _elem525 = iprot.readI64();
22558 
            self.success.append(_elem525)
4715 varun.gupt 22559 
          iprot.readListEnd()
22560 
        else:
22561 
          iprot.skip(ftype)
22562 
      elif fid == 1:
22563 
        if ftype == TType.STRUCT:
22564 
          self.ex = TransactionServiceException()
22565 
          self.ex.read(iprot)
22566 
        else:
22567 
          iprot.skip(ftype)
22568 
      else:
22569 
        iprot.skip(ftype)
22570 
      iprot.readFieldEnd()
22571 
    iprot.readStructEnd()
22572 
 
22573 
  def write(self, oprot):
22574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22576 
      return
22577 
    oprot.writeStructBegin('getReshippedOrderIds_result')
22578 
    if self.success is not None:
22579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22580 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22581 
      for iter526 in self.success:
22582 
        oprot.writeI64(iter526)
4715 varun.gupt 22583 
      oprot.writeListEnd()
22584 
      oprot.writeFieldEnd()
22585 
    if self.ex is not None:
22586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22587 
      self.ex.write(oprot)
22588 
      oprot.writeFieldEnd()
22589 
    oprot.writeFieldStop()
22590 
    oprot.writeStructEnd()
22591 
 
22592 
  def validate(self):
22593 
    return
22594 
 
22595 
 
22596 
  def __repr__(self):
22597 
    L = ['%s=%r' % (key, value)
22598 
      for key, value in self.__dict__.iteritems()]
22599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22600 
 
22601 
  def __eq__(self, other):
22602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22603 
 
22604 
  def __ne__(self, other):
22605 
    return not (self == other)
4757 mandeep.dh 22606 
 
5481 phani.kuma 22607 
class getBilledOrders_args:
4875 varun.gupt 22608 
  """
22609 
  Attributes:
22610 
   - vendorId
5481 phani.kuma 22611 
   - onlyVendorNotPaid
22612 
   - billingDateFrom
22613 
   - billingDateTo
4875 varun.gupt 22614 
  """
22615 
 
22616 
  thrift_spec = (
22617 
    None, # 0
22618 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 22619 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
22620 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
22621 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 22622 
  )
22623 
 
5481 phani.kuma 22624 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 22625 
    self.vendorId = vendorId
5481 phani.kuma 22626 
    self.onlyVendorNotPaid = onlyVendorNotPaid
22627 
    self.billingDateFrom = billingDateFrom
22628 
    self.billingDateTo = billingDateTo
4875 varun.gupt 22629 
 
22630 
  def read(self, iprot):
22631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22633 
      return
22634 
    iprot.readStructBegin()
22635 
    while True:
22636 
      (fname, ftype, fid) = iprot.readFieldBegin()
22637 
      if ftype == TType.STOP:
22638 
        break
22639 
      if fid == 1:
22640 
        if ftype == TType.I64:
22641 
          self.vendorId = iprot.readI64();
22642 
        else:
22643 
          iprot.skip(ftype)
5481 phani.kuma 22644 
      elif fid == 2:
22645 
        if ftype == TType.BOOL:
22646 
          self.onlyVendorNotPaid = iprot.readBool();
22647 
        else:
22648 
          iprot.skip(ftype)
22649 
      elif fid == 3:
22650 
        if ftype == TType.I64:
22651 
          self.billingDateFrom = iprot.readI64();
22652 
        else:
22653 
          iprot.skip(ftype)
22654 
      elif fid == 4:
22655 
        if ftype == TType.I64:
22656 
          self.billingDateTo = iprot.readI64();
22657 
        else:
22658 
          iprot.skip(ftype)
4875 varun.gupt 22659 
      else:
22660 
        iprot.skip(ftype)
22661 
      iprot.readFieldEnd()
22662 
    iprot.readStructEnd()
22663 
 
22664 
  def write(self, oprot):
22665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22667 
      return
5481 phani.kuma 22668 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 22669 
    if self.vendorId is not None:
22670 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22671 
      oprot.writeI64(self.vendorId)
22672 
      oprot.writeFieldEnd()
5481 phani.kuma 22673 
    if self.onlyVendorNotPaid is not None:
22674 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
22675 
      oprot.writeBool(self.onlyVendorNotPaid)
22676 
      oprot.writeFieldEnd()
22677 
    if self.billingDateFrom is not None:
22678 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
22679 
      oprot.writeI64(self.billingDateFrom)
22680 
      oprot.writeFieldEnd()
22681 
    if self.billingDateTo is not None:
22682 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
22683 
      oprot.writeI64(self.billingDateTo)
22684 
      oprot.writeFieldEnd()
4875 varun.gupt 22685 
    oprot.writeFieldStop()
22686 
    oprot.writeStructEnd()
22687 
 
22688 
  def validate(self):
22689 
    return
22690 
 
22691 
 
22692 
  def __repr__(self):
22693 
    L = ['%s=%r' % (key, value)
22694 
      for key, value in self.__dict__.iteritems()]
22695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22696 
 
22697 
  def __eq__(self, other):
22698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22699 
 
22700 
  def __ne__(self, other):
22701 
    return not (self == other)
22702 
 
5481 phani.kuma 22703 
class getBilledOrders_result:
4875 varun.gupt 22704 
  """
22705 
  Attributes:
22706 
   - success
22707 
   - ex
22708 
  """
22709 
 
22710 
  thrift_spec = (
22711 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22713 
  )
22714 
 
22715 
  def __init__(self, success=None, ex=None,):
22716 
    self.success = success
22717 
    self.ex = ex
22718 
 
22719 
  def read(self, iprot):
22720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22722 
      return
22723 
    iprot.readStructBegin()
22724 
    while True:
22725 
      (fname, ftype, fid) = iprot.readFieldBegin()
22726 
      if ftype == TType.STOP:
22727 
        break
22728 
      if fid == 0:
22729 
        if ftype == TType.LIST:
22730 
          self.success = []
5481 phani.kuma 22731 
          (_etype530, _size527) = iprot.readListBegin()
22732 
          for _i531 in xrange(_size527):
22733 
            _elem532 = Order()
22734 
            _elem532.read(iprot)
22735 
            self.success.append(_elem532)
4875 varun.gupt 22736 
          iprot.readListEnd()
22737 
        else:
22738 
          iprot.skip(ftype)
22739 
      elif fid == 1:
22740 
        if ftype == TType.STRUCT:
22741 
          self.ex = TransactionServiceException()
22742 
          self.ex.read(iprot)
22743 
        else:
22744 
          iprot.skip(ftype)
22745 
      else:
22746 
        iprot.skip(ftype)
22747 
      iprot.readFieldEnd()
22748 
    iprot.readStructEnd()
22749 
 
22750 
  def write(self, oprot):
22751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22753 
      return
5481 phani.kuma 22754 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 22755 
    if self.success is not None:
22756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22757 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22758 
      for iter533 in self.success:
22759 
        iter533.write(oprot)
4875 varun.gupt 22760 
      oprot.writeListEnd()
22761 
      oprot.writeFieldEnd()
22762 
    if self.ex is not None:
22763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22764 
      self.ex.write(oprot)
22765 
      oprot.writeFieldEnd()
22766 
    oprot.writeFieldStop()
22767 
    oprot.writeStructEnd()
22768 
 
22769 
  def validate(self):
22770 
    return
22771 
 
22772 
 
22773 
  def __repr__(self):
22774 
    L = ['%s=%r' % (key, value)
22775 
      for key, value in self.__dict__.iteritems()]
22776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22777 
 
22778 
  def __eq__(self, other):
22779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22780 
 
22781 
  def __ne__(self, other):
22782 
    return not (self == other)
5031 varun.gupt 22783 
 
22784 
class getStatusDistributionOfOrders_args:
22785 
  """
22786 
  Attributes:
22787 
   - startDate
22788 
   - endDate
22789 
  """
22790 
 
22791 
  thrift_spec = (
22792 
    None, # 0
22793 
    (1, TType.I64, 'startDate', None, None, ), # 1
22794 
    (2, TType.I64, 'endDate', None, None, ), # 2
22795 
  )
22796 
 
22797 
  def __init__(self, startDate=None, endDate=None,):
22798 
    self.startDate = startDate
22799 
    self.endDate = endDate
22800 
 
22801 
  def read(self, iprot):
22802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22804 
      return
22805 
    iprot.readStructBegin()
22806 
    while True:
22807 
      (fname, ftype, fid) = iprot.readFieldBegin()
22808 
      if ftype == TType.STOP:
22809 
        break
22810 
      if fid == 1:
22811 
        if ftype == TType.I64:
22812 
          self.startDate = iprot.readI64();
22813 
        else:
22814 
          iprot.skip(ftype)
22815 
      elif fid == 2:
22816 
        if ftype == TType.I64:
22817 
          self.endDate = iprot.readI64();
22818 
        else:
22819 
          iprot.skip(ftype)
22820 
      else:
22821 
        iprot.skip(ftype)
22822 
      iprot.readFieldEnd()
22823 
    iprot.readStructEnd()
22824 
 
22825 
  def write(self, oprot):
22826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22828 
      return
22829 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22830 
    if self.startDate is not None:
22831 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22832 
      oprot.writeI64(self.startDate)
22833 
      oprot.writeFieldEnd()
22834 
    if self.endDate is not None:
22835 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22836 
      oprot.writeI64(self.endDate)
22837 
      oprot.writeFieldEnd()
22838 
    oprot.writeFieldStop()
22839 
    oprot.writeStructEnd()
22840 
 
22841 
  def validate(self):
22842 
    return
22843 
 
22844 
 
22845 
  def __repr__(self):
22846 
    L = ['%s=%r' % (key, value)
22847 
      for key, value in self.__dict__.iteritems()]
22848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22849 
 
22850 
  def __eq__(self, other):
22851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22852 
 
22853 
  def __ne__(self, other):
22854 
    return not (self == other)
22855 
 
22856 
class getStatusDistributionOfOrders_result:
22857 
  """
22858 
  Attributes:
22859 
   - success
22860 
   - ex
22861 
  """
22862 
 
22863 
  thrift_spec = (
22864 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22865 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22866 
  )
22867 
 
22868 
  def __init__(self, success=None, ex=None,):
22869 
    self.success = success
22870 
    self.ex = ex
22871 
 
22872 
  def read(self, iprot):
22873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22875 
      return
22876 
    iprot.readStructBegin()
22877 
    while True:
22878 
      (fname, ftype, fid) = iprot.readFieldBegin()
22879 
      if ftype == TType.STOP:
22880 
        break
22881 
      if fid == 0:
22882 
        if ftype == TType.MAP:
22883 
          self.success = {}
5481 phani.kuma 22884 
          (_ktype535, _vtype536, _size534 ) = iprot.readMapBegin()
22885 
          for _i538 in xrange(_size534):
22886 
            _key539 = iprot.readI64();
22887 
            _val540 = iprot.readI64();
22888 
            self.success[_key539] = _val540
5031 varun.gupt 22889 
          iprot.readMapEnd()
22890 
        else:
22891 
          iprot.skip(ftype)
22892 
      elif fid == 1:
22893 
        if ftype == TType.STRUCT:
22894 
          self.ex = TransactionServiceException()
22895 
          self.ex.read(iprot)
22896 
        else:
22897 
          iprot.skip(ftype)
22898 
      else:
22899 
        iprot.skip(ftype)
22900 
      iprot.readFieldEnd()
22901 
    iprot.readStructEnd()
22902 
 
22903 
  def write(self, oprot):
22904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22906 
      return
22907 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22908 
    if self.success is not None:
22909 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22910 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 22911 
      for kiter541,viter542 in self.success.items():
22912 
        oprot.writeI64(kiter541)
22913 
        oprot.writeI64(viter542)
5031 varun.gupt 22914 
      oprot.writeMapEnd()
22915 
      oprot.writeFieldEnd()
22916 
    if self.ex is not None:
22917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22918 
      self.ex.write(oprot)
22919 
      oprot.writeFieldEnd()
22920 
    oprot.writeFieldStop()
22921 
    oprot.writeStructEnd()
22922 
 
22923 
  def validate(self):
22924 
    return
22925 
 
22926 
 
22927 
  def __repr__(self):
22928 
    L = ['%s=%r' % (key, value)
22929 
      for key, value in self.__dict__.iteritems()]
22930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22931 
 
22932 
  def __eq__(self, other):
22933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22934 
 
22935 
  def __ne__(self, other):
22936 
    return not (self == other)
5067 varun.gupt 22937 
 
22938 
class getOrderIdsForStatus_args:
22939 
  """
22940 
  Attributes:
22941 
   - status
22942 
   - startDatetime
22943 
   - endDatetime
22944 
  """
22945 
 
22946 
  thrift_spec = (
22947 
    None, # 0
22948 
    (1, TType.I64, 'status', None, None, ), # 1
22949 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22950 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22951 
  )
22952 
 
22953 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22954 
    self.status = status
22955 
    self.startDatetime = startDatetime
22956 
    self.endDatetime = endDatetime
22957 
 
22958 
  def read(self, iprot):
22959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22961 
      return
22962 
    iprot.readStructBegin()
22963 
    while True:
22964 
      (fname, ftype, fid) = iprot.readFieldBegin()
22965 
      if ftype == TType.STOP:
22966 
        break
22967 
      if fid == 1:
22968 
        if ftype == TType.I64:
22969 
          self.status = iprot.readI64();
22970 
        else:
22971 
          iprot.skip(ftype)
22972 
      elif fid == 2:
22973 
        if ftype == TType.I64:
22974 
          self.startDatetime = iprot.readI64();
22975 
        else:
22976 
          iprot.skip(ftype)
22977 
      elif fid == 3:
22978 
        if ftype == TType.I64:
22979 
          self.endDatetime = iprot.readI64();
22980 
        else:
22981 
          iprot.skip(ftype)
22982 
      else:
22983 
        iprot.skip(ftype)
22984 
      iprot.readFieldEnd()
22985 
    iprot.readStructEnd()
22986 
 
22987 
  def write(self, oprot):
22988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22990 
      return
22991 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22992 
    if self.status is not None:
22993 
      oprot.writeFieldBegin('status', TType.I64, 1)
22994 
      oprot.writeI64(self.status)
22995 
      oprot.writeFieldEnd()
22996 
    if self.startDatetime is not None:
22997 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22998 
      oprot.writeI64(self.startDatetime)
22999 
      oprot.writeFieldEnd()
23000 
    if self.endDatetime is not None:
23001 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23002 
      oprot.writeI64(self.endDatetime)
23003 
      oprot.writeFieldEnd()
23004 
    oprot.writeFieldStop()
23005 
    oprot.writeStructEnd()
23006 
 
23007 
  def validate(self):
23008 
    return
23009 
 
23010 
 
23011 
  def __repr__(self):
23012 
    L = ['%s=%r' % (key, value)
23013 
      for key, value in self.__dict__.iteritems()]
23014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23015 
 
23016 
  def __eq__(self, other):
23017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23018 
 
23019 
  def __ne__(self, other):
23020 
    return not (self == other)
23021 
 
23022 
class getOrderIdsForStatus_result:
23023 
  """
23024 
  Attributes:
23025 
   - success
23026 
   - ex
23027 
  """
23028 
 
23029 
  thrift_spec = (
23030 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23032 
  )
23033 
 
23034 
  def __init__(self, success=None, ex=None,):
23035 
    self.success = success
23036 
    self.ex = ex
23037 
 
23038 
  def read(self, iprot):
23039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23041 
      return
23042 
    iprot.readStructBegin()
23043 
    while True:
23044 
      (fname, ftype, fid) = iprot.readFieldBegin()
23045 
      if ftype == TType.STOP:
23046 
        break
23047 
      if fid == 0:
23048 
        if ftype == TType.LIST:
23049 
          self.success = []
5481 phani.kuma 23050 
          (_etype546, _size543) = iprot.readListBegin()
23051 
          for _i547 in xrange(_size543):
23052 
            _elem548 = iprot.readI64();
23053 
            self.success.append(_elem548)
5067 varun.gupt 23054 
          iprot.readListEnd()
23055 
        else:
23056 
          iprot.skip(ftype)
23057 
      elif fid == 1:
23058 
        if ftype == TType.STRUCT:
23059 
          self.ex = TransactionServiceException()
23060 
          self.ex.read(iprot)
23061 
        else:
23062 
          iprot.skip(ftype)
23063 
      else:
23064 
        iprot.skip(ftype)
23065 
      iprot.readFieldEnd()
23066 
    iprot.readStructEnd()
23067 
 
23068 
  def write(self, oprot):
23069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23071 
      return
23072 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23073 
    if self.success is not None:
23074 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23075 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 23076 
      for iter549 in self.success:
23077 
        oprot.writeI64(iter549)
5067 varun.gupt 23078 
      oprot.writeListEnd()
23079 
      oprot.writeFieldEnd()
23080 
    if self.ex is not None:
23081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23082 
      self.ex.write(oprot)
23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
5099 varun.gupt 23101 
 
5348 anupam.sin 23102 
class updateCODAgent_args:
23103 
  """
23104 
  Attributes:
23105 
   - agent
23106 
   - orderId
23107 
  """
23108 
 
23109 
  thrift_spec = (
23110 
    None, # 0
23111 
    (1, TType.STRING, 'agent', None, None, ), # 1
23112 
    (2, TType.I64, 'orderId', None, None, ), # 2
23113 
  )
23114 
 
23115 
  def __init__(self, agent=None, orderId=None,):
23116 
    self.agent = agent
23117 
    self.orderId = orderId
23118 
 
23119 
  def read(self, iprot):
23120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23122 
      return
23123 
    iprot.readStructBegin()
23124 
    while True:
23125 
      (fname, ftype, fid) = iprot.readFieldBegin()
23126 
      if ftype == TType.STOP:
23127 
        break
23128 
      if fid == 1:
23129 
        if ftype == TType.STRING:
23130 
          self.agent = iprot.readString();
23131 
        else:
23132 
          iprot.skip(ftype)
23133 
      elif fid == 2:
23134 
        if ftype == TType.I64:
23135 
          self.orderId = iprot.readI64();
23136 
        else:
23137 
          iprot.skip(ftype)
23138 
      else:
23139 
        iprot.skip(ftype)
23140 
      iprot.readFieldEnd()
23141 
    iprot.readStructEnd()
23142 
 
23143 
  def write(self, oprot):
23144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23146 
      return
23147 
    oprot.writeStructBegin('updateCODAgent_args')
23148 
    if self.agent is not None:
23149 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23150 
      oprot.writeString(self.agent)
23151 
      oprot.writeFieldEnd()
23152 
    if self.orderId is not None:
23153 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23154 
      oprot.writeI64(self.orderId)
23155 
      oprot.writeFieldEnd()
23156 
    oprot.writeFieldStop()
23157 
    oprot.writeStructEnd()
23158 
 
23159 
  def validate(self):
23160 
    return
23161 
 
23162 
 
23163 
  def __repr__(self):
23164 
    L = ['%s=%r' % (key, value)
23165 
      for key, value in self.__dict__.iteritems()]
23166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23167 
 
23168 
  def __eq__(self, other):
23169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23170 
 
23171 
  def __ne__(self, other):
23172 
    return not (self == other)
23173 
 
23174 
class updateCODAgent_result:
23175 
  """
23176 
  Attributes:
23177 
   - ex
23178 
  """
23179 
 
23180 
  thrift_spec = (
23181 
    None, # 0
23182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23183 
  )
23184 
 
23185 
  def __init__(self, ex=None,):
23186 
    self.ex = ex
23187 
 
23188 
  def read(self, iprot):
23189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23191 
      return
23192 
    iprot.readStructBegin()
23193 
    while True:
23194 
      (fname, ftype, fid) = iprot.readFieldBegin()
23195 
      if ftype == TType.STOP:
23196 
        break
23197 
      if fid == 1:
23198 
        if ftype == TType.STRUCT:
23199 
          self.ex = TransactionServiceException()
23200 
          self.ex.read(iprot)
23201 
        else:
23202 
          iprot.skip(ftype)
23203 
      else:
23204 
        iprot.skip(ftype)
23205 
      iprot.readFieldEnd()
23206 
    iprot.readStructEnd()
23207 
 
23208 
  def write(self, oprot):
23209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23211 
      return
23212 
    oprot.writeStructBegin('updateCODAgent_result')
23213 
    if self.ex is not None:
23214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23215 
      self.ex.write(oprot)
23216 
      oprot.writeFieldEnd()
23217 
    oprot.writeFieldStop()
23218 
    oprot.writeStructEnd()
23219 
 
23220 
  def validate(self):
23221 
    return
23222 
 
23223 
 
23224 
  def __repr__(self):
23225 
    L = ['%s=%r' % (key, value)
23226 
      for key, value in self.__dict__.iteritems()]
23227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23228 
 
23229 
  def __eq__(self, other):
23230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23231 
 
23232 
  def __ne__(self, other):
23233 
    return not (self == other)
23234 
 
5099 varun.gupt 23235 
class updateOrderAsPaidToVendor_args:
23236 
  """
23237 
  Attributes:
23238 
   - orderId
23239 
  """
23240 
 
23241 
  thrift_spec = (
23242 
    None, # 0
23243 
    (1, TType.I64, 'orderId', None, None, ), # 1
23244 
  )
23245 
 
23246 
  def __init__(self, orderId=None,):
23247 
    self.orderId = orderId
23248 
 
23249 
  def read(self, iprot):
23250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23252 
      return
23253 
    iprot.readStructBegin()
23254 
    while True:
23255 
      (fname, ftype, fid) = iprot.readFieldBegin()
23256 
      if ftype == TType.STOP:
23257 
        break
23258 
      if fid == 1:
23259 
        if ftype == TType.I64:
23260 
          self.orderId = iprot.readI64();
23261 
        else:
23262 
          iprot.skip(ftype)
23263 
      else:
23264 
        iprot.skip(ftype)
23265 
      iprot.readFieldEnd()
23266 
    iprot.readStructEnd()
23267 
 
23268 
  def write(self, oprot):
23269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23271 
      return
23272 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23273 
    if self.orderId is not None:
23274 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23275 
      oprot.writeI64(self.orderId)
23276 
      oprot.writeFieldEnd()
23277 
    oprot.writeFieldStop()
23278 
    oprot.writeStructEnd()
23279 
 
23280 
  def validate(self):
23281 
    return
23282 
 
23283 
 
23284 
  def __repr__(self):
23285 
    L = ['%s=%r' % (key, value)
23286 
      for key, value in self.__dict__.iteritems()]
23287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23288 
 
23289 
  def __eq__(self, other):
23290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23291 
 
23292 
  def __ne__(self, other):
23293 
    return not (self == other)
23294 
 
23295 
class updateOrderAsPaidToVendor_result:
23296 
  """
23297 
  Attributes:
23298 
   - ex
23299 
  """
23300 
 
23301 
  thrift_spec = (
23302 
    None, # 0
23303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23304 
  )
23305 
 
23306 
  def __init__(self, ex=None,):
23307 
    self.ex = ex
23308 
 
23309 
  def read(self, iprot):
23310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23312 
      return
23313 
    iprot.readStructBegin()
23314 
    while True:
23315 
      (fname, ftype, fid) = iprot.readFieldBegin()
23316 
      if ftype == TType.STOP:
23317 
        break
23318 
      if fid == 1:
23319 
        if ftype == TType.STRUCT:
23320 
          self.ex = TransactionServiceException()
23321 
          self.ex.read(iprot)
23322 
        else:
23323 
          iprot.skip(ftype)
23324 
      else:
23325 
        iprot.skip(ftype)
23326 
      iprot.readFieldEnd()
23327 
    iprot.readStructEnd()
23328 
 
23329 
  def write(self, oprot):
23330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23332 
      return
23333 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23334 
    if self.ex is not None:
23335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23336 
      self.ex.write(oprot)
23337 
      oprot.writeFieldEnd()
23338 
    oprot.writeFieldStop()
23339 
    oprot.writeStructEnd()
23340 
 
23341 
  def validate(self):
23342 
    return
23343 
 
23344 
 
23345 
  def __repr__(self):
23346 
    L = ['%s=%r' % (key, value)
23347 
      for key, value in self.__dict__.iteritems()]
23348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23349 
 
23350 
  def __eq__(self, other):
23351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23352 
 
23353 
  def __ne__(self, other):
23354 
    return not (self == other)
5208 varun.gupt 23355 
 
5386 phani.kuma 23356 
class updateOrderOnlyAsPaidToVendor_args:
23357 
  """
23358 
  Attributes:
23359 
   - orderId
23360 
  """
23361 
 
23362 
  thrift_spec = (
23363 
    None, # 0
23364 
    (1, TType.I64, 'orderId', None, None, ), # 1
23365 
  )
23366 
 
23367 
  def __init__(self, orderId=None,):
23368 
    self.orderId = orderId
23369 
 
23370 
  def read(self, iprot):
23371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23373 
      return
23374 
    iprot.readStructBegin()
23375 
    while True:
23376 
      (fname, ftype, fid) = iprot.readFieldBegin()
23377 
      if ftype == TType.STOP:
23378 
        break
23379 
      if fid == 1:
23380 
        if ftype == TType.I64:
23381 
          self.orderId = iprot.readI64();
23382 
        else:
23383 
          iprot.skip(ftype)
23384 
      else:
23385 
        iprot.skip(ftype)
23386 
      iprot.readFieldEnd()
23387 
    iprot.readStructEnd()
23388 
 
23389 
  def write(self, oprot):
23390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23392 
      return
23393 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23394 
    if self.orderId is not None:
23395 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23396 
      oprot.writeI64(self.orderId)
23397 
      oprot.writeFieldEnd()
23398 
    oprot.writeFieldStop()
23399 
    oprot.writeStructEnd()
23400 
 
23401 
  def validate(self):
23402 
    return
23403 
 
23404 
 
23405 
  def __repr__(self):
23406 
    L = ['%s=%r' % (key, value)
23407 
      for key, value in self.__dict__.iteritems()]
23408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23409 
 
23410 
  def __eq__(self, other):
23411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23412 
 
23413 
  def __ne__(self, other):
23414 
    return not (self == other)
23415 
 
23416 
class updateOrderOnlyAsPaidToVendor_result:
23417 
  """
23418 
  Attributes:
23419 
   - ex
23420 
  """
23421 
 
23422 
  thrift_spec = (
23423 
    None, # 0
23424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23425 
  )
23426 
 
23427 
  def __init__(self, ex=None,):
23428 
    self.ex = ex
23429 
 
23430 
  def read(self, iprot):
23431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23433 
      return
23434 
    iprot.readStructBegin()
23435 
    while True:
23436 
      (fname, ftype, fid) = iprot.readFieldBegin()
23437 
      if ftype == TType.STOP:
23438 
        break
23439 
      if fid == 1:
23440 
        if ftype == TType.STRUCT:
23441 
          self.ex = TransactionServiceException()
23442 
          self.ex.read(iprot)
23443 
        else:
23444 
          iprot.skip(ftype)
23445 
      else:
23446 
        iprot.skip(ftype)
23447 
      iprot.readFieldEnd()
23448 
    iprot.readStructEnd()
23449 
 
23450 
  def write(self, oprot):
23451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23453 
      return
23454 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23455 
    if self.ex is not None:
23456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23457 
      self.ex.write(oprot)
23458 
      oprot.writeFieldEnd()
23459 
    oprot.writeFieldStop()
23460 
    oprot.writeStructEnd()
23461 
 
23462 
  def validate(self):
23463 
    return
23464 
 
23465 
 
23466 
  def __repr__(self):
23467 
    L = ['%s=%r' % (key, value)
23468 
      for key, value in self.__dict__.iteritems()]
23469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23470 
 
23471 
  def __eq__(self, other):
23472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23473 
 
23474 
  def __ne__(self, other):
23475 
    return not (self == other)
23476 
 
5208 varun.gupt 23477 
class getRefundedOrdersMarkedPaid_args:
23478 
 
23479 
  thrift_spec = (
23480 
  )
23481 
 
23482 
  def read(self, iprot):
23483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23485 
      return
23486 
    iprot.readStructBegin()
23487 
    while True:
23488 
      (fname, ftype, fid) = iprot.readFieldBegin()
23489 
      if ftype == TType.STOP:
23490 
        break
23491 
      else:
23492 
        iprot.skip(ftype)
23493 
      iprot.readFieldEnd()
23494 
    iprot.readStructEnd()
23495 
 
23496 
  def write(self, oprot):
23497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23499 
      return
23500 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23501 
    oprot.writeFieldStop()
23502 
    oprot.writeStructEnd()
23503 
 
23504 
  def validate(self):
23505 
    return
23506 
 
23507 
 
23508 
  def __repr__(self):
23509 
    L = ['%s=%r' % (key, value)
23510 
      for key, value in self.__dict__.iteritems()]
23511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23512 
 
23513 
  def __eq__(self, other):
23514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23515 
 
23516 
  def __ne__(self, other):
23517 
    return not (self == other)
23518 
 
23519 
class getRefundedOrdersMarkedPaid_result:
23520 
  """
23521 
  Attributes:
23522 
   - success
23523 
   - ex
23524 
  """
23525 
 
23526 
  thrift_spec = (
23527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23529 
  )
23530 
 
23531 
  def __init__(self, success=None, ex=None,):
23532 
    self.success = success
23533 
    self.ex = ex
23534 
 
23535 
  def read(self, iprot):
23536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23538 
      return
23539 
    iprot.readStructBegin()
23540 
    while True:
23541 
      (fname, ftype, fid) = iprot.readFieldBegin()
23542 
      if ftype == TType.STOP:
23543 
        break
23544 
      if fid == 0:
23545 
        if ftype == TType.LIST:
23546 
          self.success = []
5481 phani.kuma 23547 
          (_etype553, _size550) = iprot.readListBegin()
23548 
          for _i554 in xrange(_size550):
23549 
            _elem555 = Order()
23550 
            _elem555.read(iprot)
23551 
            self.success.append(_elem555)
5208 varun.gupt 23552 
          iprot.readListEnd()
23553 
        else:
23554 
          iprot.skip(ftype)
23555 
      elif fid == 1:
23556 
        if ftype == TType.STRUCT:
23557 
          self.ex = TransactionServiceException()
23558 
          self.ex.read(iprot)
23559 
        else:
23560 
          iprot.skip(ftype)
23561 
      else:
23562 
        iprot.skip(ftype)
23563 
      iprot.readFieldEnd()
23564 
    iprot.readStructEnd()
23565 
 
23566 
  def write(self, oprot):
23567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23569 
      return
23570 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23571 
    if self.success is not None:
23572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23574 
      for iter556 in self.success:
23575 
        iter556.write(oprot)
5208 varun.gupt 23576 
      oprot.writeListEnd()
23577 
      oprot.writeFieldEnd()
23578 
    if self.ex is not None:
23579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23580 
      self.ex.write(oprot)
23581 
      oprot.writeFieldEnd()
23582 
    oprot.writeFieldStop()
23583 
    oprot.writeStructEnd()
23584 
 
23585 
  def validate(self):
23586 
    return
23587 
 
23588 
 
23589 
  def __repr__(self):
23590 
    L = ['%s=%r' % (key, value)
23591 
      for key, value in self.__dict__.iteritems()]
23592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23593 
 
23594 
  def __eq__(self, other):
23595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23596 
 
23597 
  def __ne__(self, other):
23598 
    return not (self == other)
5447 anupam.sin 23599 
 
23600 
class getAllVerificationAgents_args:
23601 
  """
23602 
  Attributes:
23603 
   - minOrderId
23604 
   - maxOrderId
23605 
  """
23606 
 
23607 
  thrift_spec = (
23608 
    None, # 0
23609 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
23610 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
23611 
  )
23612 
 
23613 
  def __init__(self, minOrderId=None, maxOrderId=None,):
23614 
    self.minOrderId = minOrderId
23615 
    self.maxOrderId = maxOrderId
23616 
 
23617 
  def read(self, iprot):
23618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23620 
      return
23621 
    iprot.readStructBegin()
23622 
    while True:
23623 
      (fname, ftype, fid) = iprot.readFieldBegin()
23624 
      if ftype == TType.STOP:
23625 
        break
23626 
      if fid == 1:
23627 
        if ftype == TType.I64:
23628 
          self.minOrderId = iprot.readI64();
23629 
        else:
23630 
          iprot.skip(ftype)
23631 
      elif fid == 2:
23632 
        if ftype == TType.I64:
23633 
          self.maxOrderId = iprot.readI64();
23634 
        else:
23635 
          iprot.skip(ftype)
23636 
      else:
23637 
        iprot.skip(ftype)
23638 
      iprot.readFieldEnd()
23639 
    iprot.readStructEnd()
23640 
 
23641 
  def write(self, oprot):
23642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23644 
      return
23645 
    oprot.writeStructBegin('getAllVerificationAgents_args')
23646 
    if self.minOrderId is not None:
23647 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
23648 
      oprot.writeI64(self.minOrderId)
23649 
      oprot.writeFieldEnd()
23650 
    if self.maxOrderId is not None:
23651 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
23652 
      oprot.writeI64(self.maxOrderId)
23653 
      oprot.writeFieldEnd()
23654 
    oprot.writeFieldStop()
23655 
    oprot.writeStructEnd()
23656 
 
23657 
  def validate(self):
23658 
    return
23659 
 
23660 
 
23661 
  def __repr__(self):
23662 
    L = ['%s=%r' % (key, value)
23663 
      for key, value in self.__dict__.iteritems()]
23664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23665 
 
23666 
  def __eq__(self, other):
23667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23668 
 
23669 
  def __ne__(self, other):
23670 
    return not (self == other)
23671 
 
23672 
class getAllVerificationAgents_result:
23673 
  """
23674 
  Attributes:
23675 
   - success
23676 
  """
23677 
 
23678 
  thrift_spec = (
23679 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
23680 
  )
23681 
 
23682 
  def __init__(self, success=None,):
23683 
    self.success = success
23684 
 
23685 
  def read(self, iprot):
23686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23688 
      return
23689 
    iprot.readStructBegin()
23690 
    while True:
23691 
      (fname, ftype, fid) = iprot.readFieldBegin()
23692 
      if ftype == TType.STOP:
23693 
        break
23694 
      if fid == 0:
23695 
        if ftype == TType.LIST:
23696 
          self.success = []
5481 phani.kuma 23697 
          (_etype560, _size557) = iprot.readListBegin()
23698 
          for _i561 in xrange(_size557):
23699 
            _elem562 = CODVerificationAgent()
23700 
            _elem562.read(iprot)
23701 
            self.success.append(_elem562)
5447 anupam.sin 23702 
          iprot.readListEnd()
23703 
        else:
23704 
          iprot.skip(ftype)
23705 
      else:
23706 
        iprot.skip(ftype)
23707 
      iprot.readFieldEnd()
23708 
    iprot.readStructEnd()
23709 
 
23710 
  def write(self, oprot):
23711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23713 
      return
23714 
    oprot.writeStructBegin('getAllVerificationAgents_result')
23715 
    if self.success is not None:
23716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23718 
      for iter563 in self.success:
23719 
        iter563.write(oprot)
5447 anupam.sin 23720 
      oprot.writeListEnd()
23721 
      oprot.writeFieldEnd()
23722 
    oprot.writeFieldStop()
23723 
    oprot.writeStructEnd()
23724 
 
23725 
  def validate(self):
23726 
    return
23727 
 
23728 
 
23729 
  def __repr__(self):
23730 
    L = ['%s=%r' % (key, value)
23731 
      for key, value in self.__dict__.iteritems()]
23732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23733 
 
23734 
  def __eq__(self, other):
23735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23736 
 
23737 
  def __ne__(self, other):
23738 
    return not (self == other)
5527 anupam.sin 23739 
 
23740 
class getAllAttributesForOrderId_args:
23741 
  """
23742 
  Attributes:
23743 
   - orderId
23744 
  """
23745 
 
23746 
  thrift_spec = (
23747 
    None, # 0
23748 
    (1, TType.I64, 'orderId', None, None, ), # 1
23749 
  )
23750 
 
23751 
  def __init__(self, orderId=None,):
23752 
    self.orderId = orderId
23753 
 
23754 
  def read(self, iprot):
23755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23757 
      return
23758 
    iprot.readStructBegin()
23759 
    while True:
23760 
      (fname, ftype, fid) = iprot.readFieldBegin()
23761 
      if ftype == TType.STOP:
23762 
        break
23763 
      if fid == 1:
23764 
        if ftype == TType.I64:
23765 
          self.orderId = iprot.readI64();
23766 
        else:
23767 
          iprot.skip(ftype)
23768 
      else:
23769 
        iprot.skip(ftype)
23770 
      iprot.readFieldEnd()
23771 
    iprot.readStructEnd()
23772 
 
23773 
  def write(self, oprot):
23774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23776 
      return
23777 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
23778 
    if self.orderId is not None:
23779 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23780 
      oprot.writeI64(self.orderId)
23781 
      oprot.writeFieldEnd()
23782 
    oprot.writeFieldStop()
23783 
    oprot.writeStructEnd()
23784 
 
23785 
  def validate(self):
23786 
    return
23787 
 
23788 
 
23789 
  def __repr__(self):
23790 
    L = ['%s=%r' % (key, value)
23791 
      for key, value in self.__dict__.iteritems()]
23792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23793 
 
23794 
  def __eq__(self, other):
23795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23796 
 
23797 
  def __ne__(self, other):
23798 
    return not (self == other)
23799 
 
23800 
class getAllAttributesForOrderId_result:
23801 
  """
23802 
  Attributes:
23803 
   - success
23804 
  """
23805 
 
23806 
  thrift_spec = (
23807 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
23808 
  )
23809 
 
23810 
  def __init__(self, success=None,):
23811 
    self.success = success
23812 
 
23813 
  def read(self, iprot):
23814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23816 
      return
23817 
    iprot.readStructBegin()
23818 
    while True:
23819 
      (fname, ftype, fid) = iprot.readFieldBegin()
23820 
      if ftype == TType.STOP:
23821 
        break
23822 
      if fid == 0:
23823 
        if ftype == TType.LIST:
23824 
          self.success = []
5553 rajveer 23825 
          (_etype567, _size564) = iprot.readListBegin()
23826 
          for _i568 in xrange(_size564):
23827 
            _elem569 = Attribute()
23828 
            _elem569.read(iprot)
23829 
            self.success.append(_elem569)
5527 anupam.sin 23830 
          iprot.readListEnd()
23831 
        else:
23832 
          iprot.skip(ftype)
23833 
      else:
23834 
        iprot.skip(ftype)
23835 
      iprot.readFieldEnd()
23836 
    iprot.readStructEnd()
23837 
 
23838 
  def write(self, oprot):
23839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23841 
      return
23842 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
23843 
    if self.success is not None:
23844 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23845 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5553 rajveer 23846 
      for iter570 in self.success:
23847 
        iter570.write(oprot)
5527 anupam.sin 23848 
      oprot.writeListEnd()
23849 
      oprot.writeFieldEnd()
23850 
    oprot.writeFieldStop()
23851 
    oprot.writeStructEnd()
23852 
 
23853 
  def validate(self):
23854 
    return
23855 
 
23856 
 
23857 
  def __repr__(self):
23858 
    L = ['%s=%r' % (key, value)
23859 
      for key, value in self.__dict__.iteritems()]
23860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23861 
 
23862 
  def __eq__(self, other):
23863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23864 
 
23865 
  def __ne__(self, other):
23866 
    return not (self == other)
23867 
 
23868 
class setOrderAttributeForTransaction_args:
23869 
  """
23870 
  Attributes:
23871 
   - transactionId
23872 
   - attribute
23873 
  """
23874 
 
23875 
  thrift_spec = None
23876 
  def __init__(self, transactionId=None, attribute=None,):
23877 
    self.transactionId = transactionId
23878 
    self.attribute = attribute
23879 
 
23880 
  def read(self, iprot):
23881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23883 
      return
23884 
    iprot.readStructBegin()
23885 
    while True:
23886 
      (fname, ftype, fid) = iprot.readFieldBegin()
23887 
      if ftype == TType.STOP:
23888 
        break
23889 
      if fid == 1:
23890 
        if ftype == TType.I64:
23891 
          self.transactionId = iprot.readI64();
23892 
        else:
23893 
          iprot.skip(ftype)
23894 
      elif fid == -1:
23895 
        if ftype == TType.STRUCT:
23896 
          self.attribute = Attribute()
23897 
          self.attribute.read(iprot)
23898 
        else:
23899 
          iprot.skip(ftype)
23900 
      else:
23901 
        iprot.skip(ftype)
23902 
      iprot.readFieldEnd()
23903 
    iprot.readStructEnd()
23904 
 
23905 
  def write(self, oprot):
23906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23908 
      return
23909 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
23910 
    if self.attribute is not None:
23911 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
23912 
      self.attribute.write(oprot)
23913 
      oprot.writeFieldEnd()
23914 
    if self.transactionId is not None:
23915 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
23916 
      oprot.writeI64(self.transactionId)
23917 
      oprot.writeFieldEnd()
23918 
    oprot.writeFieldStop()
23919 
    oprot.writeStructEnd()
23920 
 
23921 
  def validate(self):
23922 
    return
23923 
 
23924 
 
23925 
  def __repr__(self):
23926 
    L = ['%s=%r' % (key, value)
23927 
      for key, value in self.__dict__.iteritems()]
23928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23929 
 
23930 
  def __eq__(self, other):
23931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23932 
 
23933 
  def __ne__(self, other):
23934 
    return not (self == other)
23935 
 
23936 
class setOrderAttributeForTransaction_result:
23937 
 
23938 
  thrift_spec = (
23939 
  )
23940 
 
23941 
  def read(self, iprot):
23942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23944 
      return
23945 
    iprot.readStructBegin()
23946 
    while True:
23947 
      (fname, ftype, fid) = iprot.readFieldBegin()
23948 
      if ftype == TType.STOP:
23949 
        break
23950 
      else:
23951 
        iprot.skip(ftype)
23952 
      iprot.readFieldEnd()
23953 
    iprot.readStructEnd()
23954 
 
23955 
  def write(self, oprot):
23956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23958 
      return
23959 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
23960 
    oprot.writeFieldStop()
23961 
    oprot.writeStructEnd()
23962 
 
23963 
  def validate(self):
23964 
    return
23965 
 
23966 
 
23967 
  def __repr__(self):
23968 
    L = ['%s=%r' % (key, value)
23969 
      for key, value in self.__dict__.iteritems()]
23970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23971 
 
23972 
  def __eq__(self, other):
23973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23974 
 
23975 
  def __ne__(self, other):
23976 
    return not (self == other)
5553 rajveer 23977 
 
23978 
class getReceivePendingOrders_args:
23979 
  """
23980 
  Attributes:
23981 
   - storeId
23982 
  """
23983 
 
23984 
  thrift_spec = (
23985 
    None, # 0
23986 
    (1, TType.I64, 'storeId', None, None, ), # 1
23987 
  )
23988 
 
23989 
  def __init__(self, storeId=None,):
23990 
    self.storeId = storeId
23991 
 
23992 
  def read(self, iprot):
23993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23995 
      return
23996 
    iprot.readStructBegin()
23997 
    while True:
23998 
      (fname, ftype, fid) = iprot.readFieldBegin()
23999 
      if ftype == TType.STOP:
24000 
        break
24001 
      if fid == 1:
24002 
        if ftype == TType.I64:
24003 
          self.storeId = iprot.readI64();
24004 
        else:
24005 
          iprot.skip(ftype)
24006 
      else:
24007 
        iprot.skip(ftype)
24008 
      iprot.readFieldEnd()
24009 
    iprot.readStructEnd()
24010 
 
24011 
  def write(self, oprot):
24012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24014 
      return
24015 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24016 
    if self.storeId is not None:
24017 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24018 
      oprot.writeI64(self.storeId)
24019 
      oprot.writeFieldEnd()
24020 
    oprot.writeFieldStop()
24021 
    oprot.writeStructEnd()
24022 
 
24023 
  def validate(self):
24024 
    return
24025 
 
24026 
 
24027 
  def __repr__(self):
24028 
    L = ['%s=%r' % (key, value)
24029 
      for key, value in self.__dict__.iteritems()]
24030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24031 
 
24032 
  def __eq__(self, other):
24033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24034 
 
24035 
  def __ne__(self, other):
24036 
    return not (self == other)
24037 
 
24038 
class getReceivePendingOrders_result:
24039 
  """
24040 
  Attributes:
24041 
   - success
24042 
  """
24043 
 
24044 
  thrift_spec = (
24045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24046 
  )
24047 
 
24048 
  def __init__(self, success=None,):
24049 
    self.success = success
24050 
 
24051 
  def read(self, iprot):
24052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24054 
      return
24055 
    iprot.readStructBegin()
24056 
    while True:
24057 
      (fname, ftype, fid) = iprot.readFieldBegin()
24058 
      if ftype == TType.STOP:
24059 
        break
24060 
      if fid == 0:
24061 
        if ftype == TType.LIST:
24062 
          self.success = []
24063 
          (_etype574, _size571) = iprot.readListBegin()
24064 
          for _i575 in xrange(_size571):
24065 
            _elem576 = Order()
24066 
            _elem576.read(iprot)
24067 
            self.success.append(_elem576)
24068 
          iprot.readListEnd()
24069 
        else:
24070 
          iprot.skip(ftype)
24071 
      else:
24072 
        iprot.skip(ftype)
24073 
      iprot.readFieldEnd()
24074 
    iprot.readStructEnd()
24075 
 
24076 
  def write(self, oprot):
24077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24079 
      return
24080 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24081 
    if self.success is not None:
24082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24084 
      for iter577 in self.success:
24085 
        iter577.write(oprot)
24086 
      oprot.writeListEnd()
24087 
      oprot.writeFieldEnd()
24088 
    oprot.writeFieldStop()
24089 
    oprot.writeStructEnd()
24090 
 
24091 
  def validate(self):
24092 
    return
24093 
 
24094 
 
24095 
  def __repr__(self):
24096 
    L = ['%s=%r' % (key, value)
24097 
      for key, value in self.__dict__.iteritems()]
24098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24099 
 
24100 
  def __eq__(self, other):
24101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24102 
 
24103 
  def __ne__(self, other):
24104 
    return not (self == other)
24105 
 
24106 
class getReceivedAtStoreOrders_args:
24107 
  """
24108 
  Attributes:
24109 
   - storeId
24110 
  """
24111 
 
24112 
  thrift_spec = (
24113 
    None, # 0
24114 
    (1, TType.I64, 'storeId', None, None, ), # 1
24115 
  )
24116 
 
24117 
  def __init__(self, storeId=None,):
24118 
    self.storeId = storeId
24119 
 
24120 
  def read(self, iprot):
24121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24123 
      return
24124 
    iprot.readStructBegin()
24125 
    while True:
24126 
      (fname, ftype, fid) = iprot.readFieldBegin()
24127 
      if ftype == TType.STOP:
24128 
        break
24129 
      if fid == 1:
24130 
        if ftype == TType.I64:
24131 
          self.storeId = iprot.readI64();
24132 
        else:
24133 
          iprot.skip(ftype)
24134 
      else:
24135 
        iprot.skip(ftype)
24136 
      iprot.readFieldEnd()
24137 
    iprot.readStructEnd()
24138 
 
24139 
  def write(self, oprot):
24140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24142 
      return
24143 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24144 
    if self.storeId is not None:
24145 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24146 
      oprot.writeI64(self.storeId)
24147 
      oprot.writeFieldEnd()
24148 
    oprot.writeFieldStop()
24149 
    oprot.writeStructEnd()
24150 
 
24151 
  def validate(self):
24152 
    return
24153 
 
24154 
 
24155 
  def __repr__(self):
24156 
    L = ['%s=%r' % (key, value)
24157 
      for key, value in self.__dict__.iteritems()]
24158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24159 
 
24160 
  def __eq__(self, other):
24161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24162 
 
24163 
  def __ne__(self, other):
24164 
    return not (self == other)
24165 
 
24166 
class getReceivedAtStoreOrders_result:
24167 
  """
24168 
  Attributes:
24169 
   - success
24170 
  """
24171 
 
24172 
  thrift_spec = (
24173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24174 
  )
24175 
 
24176 
  def __init__(self, success=None,):
24177 
    self.success = success
24178 
 
24179 
  def read(self, iprot):
24180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24182 
      return
24183 
    iprot.readStructBegin()
24184 
    while True:
24185 
      (fname, ftype, fid) = iprot.readFieldBegin()
24186 
      if ftype == TType.STOP:
24187 
        break
24188 
      if fid == 0:
24189 
        if ftype == TType.LIST:
24190 
          self.success = []
24191 
          (_etype581, _size578) = iprot.readListBegin()
24192 
          for _i582 in xrange(_size578):
24193 
            _elem583 = Order()
24194 
            _elem583.read(iprot)
24195 
            self.success.append(_elem583)
24196 
          iprot.readListEnd()
24197 
        else:
24198 
          iprot.skip(ftype)
24199 
      else:
24200 
        iprot.skip(ftype)
24201 
      iprot.readFieldEnd()
24202 
    iprot.readStructEnd()
24203 
 
24204 
  def write(self, oprot):
24205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24207 
      return
24208 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24209 
    if self.success is not None:
24210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24212 
      for iter584 in self.success:
24213 
        iter584.write(oprot)
24214 
      oprot.writeListEnd()
24215 
      oprot.writeFieldEnd()
24216 
    oprot.writeFieldStop()
24217 
    oprot.writeStructEnd()
24218 
 
24219 
  def validate(self):
24220 
    return
24221 
 
24222 
 
24223 
  def __repr__(self):
24224 
    L = ['%s=%r' % (key, value)
24225 
      for key, value in self.__dict__.iteritems()]
24226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24227 
 
24228 
  def __eq__(self, other):
24229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24230 
 
24231 
  def __ne__(self, other):
24232 
    return not (self == other)