Subversion Repositories SmartDukaan

Rev

Rev 5382 | Rev 5387 | 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 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
4999 phani.kuma 208 
  def getOrderList(self, order_ids):
209 
    """
210 
    Parameters:
211 
     - order_ids
212 
    """
213 
    pass
214 
 
5386 phani.kuma 215 
  def getOrderListForVendor(self, order_ids, vendorId):
216 
    """
217 
    Parameters:
218 
     - order_ids
219 
     - vendorId
220 
    """
221 
    pass
222 
 
1528 ankur.sing 223 
  def getOrderForCustomer(self, orderId, customerId):
224 
    """
225 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
226 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 227 
 
1528 ankur.sing 228 
    Parameters:
229 
     - orderId
230 
     - customerId
231 
    """
232 
    pass
233 
 
4444 rajveer 234 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 235 
    """
236 
    Parameters:
4394 rajveer 237 
     - type
4444 rajveer 238 
     - warehouseId
4394 rajveer 239 
     - status
240 
     - timestamp
3064 chandransh 241 
    """
242 
    pass
243 
 
4444 rajveer 244 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 245 
    """
246 
    Parameters:
247 
     - type
4444 rajveer 248 
     - warehouseId
4394 rajveer 249 
     - description
3064 chandransh 250 
    """
251 
    pass
252 
 
4444 rajveer 253 
  def markAlertsAsSeen(self, warehouseId):
254 
    """
255 
    Parameters:
256 
     - warehouseId
257 
    """
258 
    pass
259 
 
3064 chandransh 260 
  def getValidOrderCount(self, ):
261 
    """
262 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
263 
    """
264 
    pass
265 
 
266 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
267 
    """
268 
    Returns the number of distinct customers who have done successful transactions
269 
    """
270 
    pass
271 
 
272 
  def getValidOrdersAmountRange(self, ):
273 
    """
274 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
275 
    List contains two values, first minimum amount and second maximum amount.
276 
    """
277 
    pass
278 
 
279 
  def getValidOrders(self, limit):
280 
    """
281 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
282 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 283 
 
3064 chandransh 284 
    Parameters:
285 
     - limit
286 
    """
287 
    pass
288 
 
1220 chandransh 289 
  def batchOrders(self, warehouseId):
290 
    """
291 
    Create a batch of all the pending orders for the given warehouse.
292 
    The returned list is orderd by created_timestamp.
293 
    If there are no pending orders, an empty list is returned.
3431 rajveer 294 
 
1220 chandransh 295 
    Parameters:
296 
     - warehouseId
297 
    """
298 
    pass
299 
 
1208 chandransh 300 
  def markOrderAsOutOfStock(self, orderId):
301 
    """
302 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 303 
 
1208 chandransh 304 
    Parameters:
305 
     - orderId
306 
    """
307 
    pass
308 
 
3064 chandransh 309 
  def verifyOrder(self, orderId):
759 chandransh 310 
    """
3064 chandransh 311 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
312 
    timestamp. It is intended to be used for COD orders but can be harmlessly
313 
    used for all other orders as well.
314 
    Throws an exception if no such order exists.
3431 rajveer 315 
 
759 chandransh 316 
    Parameters:
3064 chandransh 317 
     - orderId
318 
    """
319 
    pass
320 
 
321 
  def acceptOrder(self, orderId):
322 
    """
323 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
324 
    given order is not a COD order, it also captures the payment if the same has
325 
    not been captured.
326 
    Throws an exception if no such order exists.
3431 rajveer 327 
 
3064 chandransh 328 
    Parameters:
329 
     - orderId
330 
    """
331 
    pass
332 
 
5110 mandeep.dh 333 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 334 
    """
335 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 336 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 337 
    the IMEI no. if a -1 is supplied.
338 
    Also, it generates an invoice number for the order, marks the order as
339 
    BILLED and sets the billing timestamp.
340 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 341 
 
3064 chandransh 342 
    Parameters:
343 
     - orderId
4283 anupam.sin 344 
     - invoice_number
4658 mandeep.dh 345 
     - serialNumber
3064 chandransh 346 
     - itemNumber
4283 anupam.sin 347 
     - billed_by
348 
     - jacketNumber
3064 chandransh 349 
     - billingType
5110 mandeep.dh 350 
     - fulfilmentWarehouseId
4763 rajveer 351 
     - authorize
3064 chandransh 352 
    """
353 
    pass
354 
 
4763 rajveer 355 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 356 
    """
357 
    Add the invoice number to the order.
358 
 
359 
    Parameters:
360 
     - orderId
361 
     - invoiceNumber
4763 rajveer 362 
     - color
4579 rajveer 363 
    """
364 
    pass
365 
 
4910 phani.kuma 366 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 367 
    """
368 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 369 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 370 
 
371 
    Parameters:
372 
     - warehouseId
373 
     - providerId
374 
     - cod
4910 phani.kuma 375 
     - orderIds
4410 rajveer 376 
    """
377 
    pass
378 
 
4910 phani.kuma 379 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 380 
    """
4910 phani.kuma 381 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
382 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 383 
 
3064 chandransh 384 
    Parameters:
759 chandransh 385 
     - providerId
4910 phani.kuma 386 
     - pickupDetails
759 chandransh 387 
    """
388 
    pass
389 
 
4910 phani.kuma 390 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 391 
    """
392 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 393 
 
1113 chandransh 394 
    Parameters:
395 
     - providerId
396 
    """
397 
    pass
398 
 
1132 chandransh 399 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
400 
    """
401 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
402 
    the name of the receiver.
403 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 404 
 
1132 chandransh 405 
    Parameters:
406 
     - providerId
407 
     - deliveredOrders
408 
    """
409 
    pass
410 
 
4910 phani.kuma 411 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 412 
    """
4910 phani.kuma 413 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 414 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 415 
 
1135 chandransh 416 
    Parameters:
417 
     - providerId
418 
     - returnedOrders
419 
    """
420 
    pass
421 
 
4910 phani.kuma 422 
  def getRTOrders(self, providerId):
423 
    """
424 
    Returns a list of orders that were returned by courier.
425 
 
426 
    Parameters:
427 
     - providerId
428 
    """
429 
    pass
430 
 
1246 chandransh 431 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
432 
    """
433 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 434 
 
1246 chandransh 435 
    Parameters:
436 
     - providerId
437 
     - undeliveredOrders
438 
    """
439 
    pass
440 
 
4910 phani.kuma 441 
  def getNonDeliveredOrdersbyCourier(self, providerId):
442 
    """
443 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
444 
 
445 
    Parameters:
446 
     - providerId
447 
    """
448 
    pass
449 
 
450 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
451 
    """
452 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
453 
 
454 
    Parameters:
455 
     - providerId
456 
     - local_connected_orders
457 
    """
458 
    pass
459 
 
460 
  def getOrdersNotLocalConnected(self, providerId):
461 
    """
462 
    Returns a list of orders that were picked up or shipped but pending local connection.
463 
 
464 
    Parameters:
465 
     - providerId
466 
    """
467 
    pass
468 
 
469 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
470 
    """
471 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
472 
 
473 
    Parameters:
474 
     - providerId
475 
     - destination_city_reached_orders
476 
    """
477 
    pass
478 
 
479 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
480 
    """
481 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
482 
 
483 
    Parameters:
484 
     - providerId
485 
     - first_atdl_orders
486 
    """
487 
    pass
488 
 
1408 ankur.sing 489 
  def getUndeliveredOrders(self, providerId, warehouseId):
490 
    """
491 
    Returns the list of orders whose delivery time has passed but have not been
492 
    delivered yet for the given provider and warehouse. To get a complete list of
493 
    undelivered orders, pass them as -1.
494 
    Returns an empty list if no such orders exist.
3431 rajveer 495 
 
1408 ankur.sing 496 
    Parameters:
497 
     - providerId
498 
     - warehouseId
499 
    """
500 
    pass
501 
 
4783 phani.kuma 502 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
503 
    """
504 
    Returns the list of orders whose expected delivery date has passed but have not been
505 
    delivered yet.
506 
    Returns an empty list if no such orders exist.
507 
    """
508 
    pass
509 
 
2536 chandransh 510 
  def toggleDOAFlag(self, orderId):
511 
    """
512 
    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.
513 
    Returns the final flag status.
514 
    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 515 
 
2536 chandransh 516 
    Parameters:
517 
     - orderId
518 
    """
519 
    pass
1886 ankur.sing 520 
 
4712 rajveer 521 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
522 
    """
523 
    Parameters:
524 
     - orderId
525 
     - deliveryTimestamp
526 
     - receiver
527 
    """
528 
    pass
529 
 
4454 rajveer 530 
  def markOrderDoaRequestReceived(self, orderId):
531 
    """
532 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
533 
 
534 
    Parameters:
535 
     - orderId
536 
    """
537 
    pass
538 
 
539 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
540 
    """
541 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
542 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
543 
 
544 
    Parameters:
545 
     - orderId
546 
     - isAuthorized
547 
    """
548 
    pass
549 
 
4488 rajveer 550 
  def markOrderReturnRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
562 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4579 rajveer 570 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 571 
    """
572 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 573 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
574 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 575 
    For any other status, it returns false.
576 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 577 
 
2536 chandransh 578 
    Parameters:
579 
     - orderId
4579 rajveer 580 
     - providerId
2536 chandransh 581 
    """
582 
    pass
583 
 
4602 rajveer 584 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 585 
    """
4452 rajveer 586 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 587 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
588 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
589 
    	3. Returns true
2591 chandransh 590 
    If the order is in any other status, it returns false.
2536 chandransh 591 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 592 
 
2536 chandransh 593 
    Parameters:
594 
     - orderId
595 
     - pickupNumber
4602 rajveer 596 
     - providerId
2536 chandransh 597 
    """
598 
    pass
599 
 
2764 chandransh 600 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
601 
    """
602 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 603 
 
2764 chandransh 604 
    Parameters:
605 
     - providerId
606 
     - pickupDetails
607 
    """
608 
    pass
609 
 
4910 phani.kuma 610 
  def getDoasNotPickedUp(self, providerId):
611 
    """
612 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
613 
 
614 
    Parameters:
615 
     - providerId
616 
    """
617 
    pass
618 
 
4741 phani.kuma 619 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
620 
    """
621 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
622 
 
623 
    Parameters:
624 
     - providerId
625 
     - pickupDetails
626 
    """
627 
    pass
628 
 
4910 phani.kuma 629 
  def getReturnOrdersNotPickedUp(self, providerId):
630 
    """
631 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
632 
 
633 
    Parameters:
634 
     - providerId
635 
    """
636 
    pass
637 
 
4479 rajveer 638 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 639 
    """
4452 rajveer 640 
    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 641 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 642 
    If the order is in any other state, it returns false.
643 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 644 
 
2591 chandransh 645 
    Parameters:
646 
     - orderId
4479 rajveer 647 
     - receiveCondition
2591 chandransh 648 
    """
649 
    pass
2536 chandransh 650 
 
2591 chandransh 651 
  def validateDoa(self, orderId, isValid):
652 
    """
4452 rajveer 653 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 654 
    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 655 
    If the order is in any other state, it returns false.
656 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 657 
 
2591 chandransh 658 
    Parameters:
659 
     - orderId
660 
     - isValid
661 
    """
662 
    pass
663 
 
4495 rajveer 664 
  def validateReturnProduct(self, orderId, isUsable):
665 
    """
666 
    Parameters:
667 
     - orderId
668 
     - isUsable
669 
    """
670 
    pass
671 
 
2616 chandransh 672 
  def reshipOrder(self, orderId):
673 
    """
4484 rajveer 674 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 675 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 676 
    	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 677 
 
678 
    If the order is in DOA_CERT_VALID state, it does the following:
679 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
680 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 681 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 682 
 
2616 chandransh 683 
    Returns the id of the newly created order.
3431 rajveer 684 
 
2616 chandransh 685 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 686 
 
2616 chandransh 687 
    Parameters:
688 
     - orderId
689 
    """
690 
    pass
2591 chandransh 691 
 
3226 chandransh 692 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a refund request for batch processing.
696 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 697 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 698 
 
2616 chandransh 699 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
700 
    	1. Creates a refund request for batch processing.
3226 chandransh 701 
    	2. Cancels the reservation of the item in the warehouse.
702 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 703 
 
3226 chandransh 704 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
705 
    	1. Cancels the reservation of the item in the warehouse.
706 
    	2. Marks the current order as CANCELED.
707 
 
708 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
709 
 
2616 chandransh 710 
    Returns True if it is successful, False otherwise.
3431 rajveer 711 
 
2616 chandransh 712 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 713 
 
2616 chandransh 714 
    Parameters:
715 
     - orderId
3226 chandransh 716 
     - refundedBy
717 
     - reason
2616 chandransh 718 
    """
719 
    pass
720 
 
2690 chandransh 721 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
722 
    """
723 
    Get all return orders created between the from and to dates for the given warehouse.
724 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 725 
 
2690 chandransh 726 
    Parameters:
727 
     - warehouseId
728 
     - fromDate
729 
     - toDate
730 
    """
731 
    pass
2616 chandransh 732 
 
2700 chandransh 733 
  def getReturnOrder(self, id):
734 
    """
735 
    Returns the ReturnOrder corresponding to the given id.
736 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 737 
 
2700 chandransh 738 
    Parameters:
739 
     - id
740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def processReturn(self, returnOrderId):
744 
    """
745 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 746 
 
2690 chandransh 747 
    Parameters:
748 
     - returnOrderId
749 
    """
750 
    pass
751 
 
3451 chandransh 752 
  def updateWeight(self, orderId, weight):
753 
    """
754 
    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 755 
 
3451 chandransh 756 
    Parameters:
757 
     - orderId
758 
     - weight
759 
    """
760 
    pass
761 
 
3469 chandransh 762 
  def changeItem(self, orderId, itemId):
763 
    """
764 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
765 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 766 
 
3469 chandransh 767 
    Parameters:
768 
     - orderId
769 
     - itemId
770 
    """
771 
    pass
772 
 
773 
  def shiftToWarehouse(self, orderId, warehouseId):
774 
    """
775 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
776 
 
777 
    Parameters:
778 
     - orderId
779 
     - warehouseId
780 
    """
781 
    pass
782 
 
4647 rajveer 783 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 784 
    """
785 
    Adds the given delay reason to the given order.
3986 chandransh 786 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 787 
    Raises an exception if no order with the given id can be found.
3469 chandransh 788 
 
3553 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - delayReason
3986 chandransh 792 
     - furtherDelay
4647 rajveer 793 
     - delayReasonText
3553 chandransh 794 
    """
795 
    pass
796 
 
3956 chandransh 797 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
798 
    """
799 
    Marks the COD orders with given AWB nos. as having been processed.
800 
    Updates the captured amount for the corresponding payment.
3553 chandransh 801 
 
3956 chandransh 802 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
803 
    1. There is no order corresponding to an AWB number.
804 
    2. The captured amount for a payment exceeds the total payment.
805 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
806 
 
807 
    Parameters:
808 
     - collectedAmountMap
809 
     - xferBy
810 
     - xferTxnId
811 
     - xferDate
812 
    """
813 
    pass
814 
 
4008 mandeep.dh 815 
  def getTransactionsRequiringExtraProcessing(self, category):
816 
    """
4065 mandeep.dh 817 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 818 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 819 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 820 
 
4008 mandeep.dh 821 
    Parameters:
822 
     - category
823 
    """
824 
    pass
825 
 
826 
  def markTransactionAsProcessed(self, transactionId, category):
827 
    """
828 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 829 
    It essentially deletes the transaction id record for a particular
830 
    processing type category (if present) from DB.
831 
    This is currently used by CRM application.
4008 mandeep.dh 832 
 
833 
    Parameters:
834 
     - transactionId
835 
     - category
836 
    """
837 
    pass
838 
 
4018 chandransh 839 
  def getItemWiseRiskyOrdersCount(self, ):
840 
    """
841 
    Returns a map containing the number of risky orders keyed by item id. A risky order
842 
    is defined as one whose shipping date is about to expire.
843 
    """
844 
    pass
4008 mandeep.dh 845 
 
4295 varun.gupt 846 
  def getOrdersForItemIds(self, itemIds):
847 
    """
848 
    Returns a list of all orders which have items with given id
849 
 
850 
    Parameters:
851 
     - itemIds
852 
    """
853 
    pass
854 
 
4247 rajveer 855 
  def markOrderCancellationRequestReceived(self, orderId):
856 
    """
857 
    Mark order as cancellation request received. If customer sends request of cancellation of
858 
    a particular order, this method will be called. It will just change status of the order
859 
    depending on its current status. It also records the previous status, so that we can move
860 
    back to that status if cancellation request is denied.
4018 chandransh 861 
 
4247 rajveer 862 
    Parameters:
863 
     - orderId
864 
    """
865 
    pass
866 
 
867 
  def markOrderCancellationRequestConfirmed(self, orderId):
868 
    """
869 
    If we decide to to cancel order, CRM will call this method to move the status of order to
870 
    cancellation request confirmed. After this OM will be able to cancel the order.
871 
 
872 
    Parameters:
873 
     - orderId
874 
    """
875 
    pass
876 
 
877 
  def markOrderCancellationRequestDenied(self, orderId):
878 
    """
879 
    If we decide to not to cancel order, we will move the order ro previous status.
880 
 
881 
    Parameters:
882 
     - orderId
883 
    """
884 
    pass
885 
 
4258 rajveer 886 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 887 
    """
4258 rajveer 888 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
889 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 890 
 
891 
    Parameters:
4258 rajveer 892 
     - transactionId
4247 rajveer 893 
    """
894 
    pass
895 
 
4259 anupam.sin 896 
  def refundTransaction(self, transactionId, refundedBy, reason):
897 
    """
898 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
899 
    need to be cancelled
4247 rajveer 900 
 
4259 anupam.sin 901 
    Parameters:
902 
     - transactionId
903 
     - refundedBy
904 
     - reason
905 
    """
906 
    pass
907 
 
4324 mandeep.dh 908 
  def updateShipmentAddress(self, orderId, addressId):
909 
    """
910 
    Updates shipment address of an order. Delivery and shipping date estimates
911 
    etc. are also updated here.
912 
 
913 
    Throws TransactionServiceException in case address change is not
914 
    possible due to certain reasons such as new pincode in address is
915 
    not serviceable etc.
916 
 
917 
    Parameters:
918 
     - orderId
919 
     - addressId
920 
    """
921 
    pass
922 
 
4285 rajveer 923 
  def acceptOrdersForItemId(self, itemId, inventory):
924 
    """
925 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
926 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 927 
 
4285 rajveer 928 
    Parameters:
929 
     - itemId
930 
     - inventory
931 
    """
932 
    pass
933 
 
4369 rajveer 934 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 935 
    """
936 
    Parameters:
937 
     - vendorId
938 
     - itemId
939 
     - quantity
940 
     - estimate
4369 rajveer 941 
     - isReminder
4303 rajveer 942 
    """
943 
    pass
4285 rajveer 944 
 
4369 rajveer 945 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 946 
    """
947 
    Parameters:
948 
     - vendorId
949 
     - itemId
950 
     - quantity
951 
     - estimate
4369 rajveer 952 
     - isReminder
4303 rajveer 953 
    """
954 
    pass
955 
 
4369 rajveer 956 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 957 
    """
958 
    Parameters:
959 
     - vendorId
960 
     - itemId
961 
     - quantity
962 
     - estimate
4369 rajveer 963 
     - isReminder
4303 rajveer 964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsTimeout(self, vendorId):
968 
    """
969 
    Parameters:
970 
     - vendorId
971 
    """
972 
    pass
4303 rajveer 973 
 
4662 rajveer 974 
  def markOrderAsLostInTransit(self, orderId):
975 
    """
976 
    Mark order as LOST_IN_TRANSIT
977 
 
978 
    Parameters:
979 
     - orderId
980 
    """
981 
    pass
982 
 
4386 anupam.sin 983 
  def getOrderForAwb(self, awb):
984 
    """
985 
    Returns the order corresponding to an AWB number
4369 rajveer 986 
 
4386 anupam.sin 987 
    Parameters:
988 
     - awb
989 
    """
990 
    pass
991 
 
4910 phani.kuma 992 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 993 
    """
4910 phani.kuma 994 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 995 
 
4506 phani.kuma 996 
    Parameters:
997 
     - logistics_provider_id
4910 phani.kuma 998 
     - order_status_list
4506 phani.kuma 999 
    """
1000 
    pass
1001 
 
4600 varun.gupt 1002 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1003 
    """
1004 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1005 
 
4600 varun.gupt 1006 
    Parameters:
1007 
     - vendorId
1008 
     - billingDateFrom
1009 
     - billingDateTo
1010 
    """
1011 
    pass
1012 
 
4607 rajveer 1013 
  def getSlippedSippingDateOrders(self, ):
1014 
    pass
1015 
 
4709 rajveer 1016 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1017 
    """
1018 
    Parameters:
1019 
     - cancelDateFrom
1020 
     - cancelDateTo
1021 
    """
1022 
    pass
1023 
 
4600 varun.gupt 1024 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1025 
    """
1026 
    Parameters:
1027 
     - mapAWBAndAmount
1028 
    """
1029 
    pass
1030 
 
4905 varun.gupt 1031 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1032 
    """
1033 
    Parameters:
1034 
     - settlementDate
1035 
     - paymentGatewayId
4905 varun.gupt 1036 
     - referenceId
4600 varun.gupt 1037 
     - serviceTax
1038 
     - otherCharges
1039 
     - netCollection
1040 
    """
1041 
    pass
1042 
 
1043 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1044 
    """
1045 
    Parameters:
1046 
     - settlementId
1047 
     - settlementDate
1048 
     - transactionDateFrom
1049 
     - transactionDateTo
1050 
     - amount
1051 
    """
1052 
    pass
1053 
 
5386 phani.kuma 1054 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1055 
    """
1056 
    Parameters:
5189 varun.gupt 1057 
     - referenceId
1058 
     - isRefund
4600 varun.gupt 1059 
    """
1060 
    pass
1061 
 
5386 phani.kuma 1062 
  def getSettlementForCod(self, orderId, isRefund):
1063 
    """
1064 
    Parameters:
1065 
     - orderId
1066 
     - isRefund
1067 
    """
1068 
    pass
1069 
 
4600 varun.gupt 1070 
  def getEBSSettlementSummaries(self, ):
1071 
    pass
1072 
 
1073 
  def markEBSSettlementUploaded(self, settlementId):
1074 
    """
1075 
    Parameters:
1076 
     - settlementId
1077 
    """
1078 
    pass
1079 
 
1080 
  def getEBSSettlementDate(self, settlementId):
1081 
    """
1082 
    Parameters:
1083 
     - settlementId
1084 
    """
1085 
    pass
1086 
 
4715 varun.gupt 1087 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1088 
    """
1089 
    Parameters:
1090 
     - settlementDateFrom
1091 
     - settlementDateTo
1092 
     - isRefund
1093 
    """
1094 
    pass
4600 varun.gupt 1095 
 
4715 varun.gupt 1096 
  def getReshippedOrderIds(self, orderIds):
1097 
    """
1098 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1099 
 
1100 
    Parameters:
1101 
     - orderIds
1102 
    """
1103 
    pass
1104 
 
4875 varun.gupt 1105 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1106 
    """
1107 
    Parameters:
1108 
     - vendorId
1109 
    """
1110 
    pass
4757 mandeep.dh 1111 
 
5031 varun.gupt 1112 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1113 
    """
1114 
    Parameters:
1115 
     - startDate
1116 
     - endDate
1117 
    """
1118 
    pass
4875 varun.gupt 1119 
 
5067 varun.gupt 1120 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1121 
    """
1122 
    Parameters:
1123 
     - status
1124 
     - startDatetime
1125 
     - endDatetime
1126 
    """
1127 
    pass
5031 varun.gupt 1128 
 
5348 anupam.sin 1129 
  def updateCODAgent(self, agent, orderId):
1130 
    """
1131 
    Updates the agent who handled the COD verification call
1132 
 
1133 
    Parameters:
1134 
     - agent
1135 
     - orderId
1136 
    """
1137 
    pass
1138 
 
5099 varun.gupt 1139 
  def updateOrderAsPaidToVendor(self, orderId):
1140 
    """
1141 
    Parameters:
1142 
     - orderId
1143 
    """
1144 
    pass
5067 varun.gupt 1145 
 
5386 phani.kuma 1146 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1147 
    """
1148 
    Parameters:
1149 
     - orderId
1150 
    """
1151 
    pass
1152 
 
5208 varun.gupt 1153 
  def getRefundedOrdersMarkedPaid(self, ):
1154 
    pass
5099 varun.gupt 1155 
 
5208 varun.gupt 1156 
 
3376 rajveer 1157 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1158 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1159 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1160 
 
1161 
  def createTransaction(self, transaction):
1162 
    """
1163 
    Parameters:
1164 
     - transaction
1165 
    """
1166 
    self.send_createTransaction(transaction)
132 ashish 1167 
    return self.recv_createTransaction()
94 ashish 1168 
 
1169 
  def send_createTransaction(self, transaction):
1170 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1171 
    args = createTransaction_args()
1172 
    args.transaction = transaction
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1177 
  def recv_createTransaction(self, ):
1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1184 
    result = createTransaction_result()
1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
3431 rajveer 1187 
    if result.success is not None:
132 ashish 1188 
      return result.success
3431 rajveer 1189 
    if result.ex is not None:
94 ashish 1190 
      raise result.ex
132 ashish 1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1192 
 
1193 
  def getTransaction(self, id):
1194 
    """
1195 
    Parameters:
1196 
     - id
1197 
    """
1198 
    self.send_getTransaction(id)
1199 
    return self.recv_getTransaction()
1200 
 
1201 
  def send_getTransaction(self, id):
1202 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1203 
    args = getTransaction_args()
1204 
    args.id = id
1205 
    args.write(self._oprot)
1206 
    self._oprot.writeMessageEnd()
1207 
    self._oprot.trans.flush()
1208 
 
1209 
  def recv_getTransaction(self, ):
1210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1211 
    if mtype == TMessageType.EXCEPTION:
1212 
      x = TApplicationException()
1213 
      x.read(self._iprot)
1214 
      self._iprot.readMessageEnd()
1215 
      raise x
1216 
    result = getTransaction_result()
1217 
    result.read(self._iprot)
1218 
    self._iprot.readMessageEnd()
3431 rajveer 1219 
    if result.success is not None:
94 ashish 1220 
      return result.success
3431 rajveer 1221 
    if result.ex is not None:
94 ashish 1222 
      raise result.ex
1223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1224 
 
1225 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1226 
    """
1227 
    Parameters:
1228 
     - customerId
1229 
     - from_date
1230 
     - to_date
1231 
     - status
1232 
    """
1233 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1234 
    return self.recv_getTransactionsForCustomer()
1235 
 
1236 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1237 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1238 
    args = getTransactionsForCustomer_args()
1239 
    args.customerId = customerId
1240 
    args.from_date = from_date
1241 
    args.to_date = to_date
1242 
    args.status = status
1243 
    args.write(self._oprot)
1244 
    self._oprot.writeMessageEnd()
1245 
    self._oprot.trans.flush()
1246 
 
1247 
  def recv_getTransactionsForCustomer(self, ):
1248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1249 
    if mtype == TMessageType.EXCEPTION:
1250 
      x = TApplicationException()
1251 
      x.read(self._iprot)
1252 
      self._iprot.readMessageEnd()
1253 
      raise x
1254 
    result = getTransactionsForCustomer_result()
1255 
    result.read(self._iprot)
1256 
    self._iprot.readMessageEnd()
3431 rajveer 1257 
    if result.success is not None:
94 ashish 1258 
      return result.success
3431 rajveer 1259 
    if result.ex is not None:
94 ashish 1260 
      raise result.ex
1261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1262 
 
132 ashish 1263 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1264 
    """
1265 
    Parameters:
1266 
     - shoppingCartId
1267 
    """
1268 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1269 
    return self.recv_getTransactionsForShoppingCartId()
1270 
 
1271 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1272 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1273 
    args = getTransactionsForShoppingCartId_args()
1274 
    args.shoppingCartId = shoppingCartId
1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_getTransactionsForShoppingCartId(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = getTransactionsForShoppingCartId_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
3431 rajveer 1289 
    if result.success is not None:
132 ashish 1290 
      return result.success
3431 rajveer 1291 
    if result.ex is not None:
132 ashish 1292 
      raise result.ex
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1294 
 
94 ashish 1295 
  def getTransactionStatus(self, transactionId):
1296 
    """
1297 
    Parameters:
1298 
     - transactionId
1299 
    """
1300 
    self.send_getTransactionStatus(transactionId)
1301 
    return self.recv_getTransactionStatus()
1302 
 
1303 
  def send_getTransactionStatus(self, transactionId):
1304 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1305 
    args = getTransactionStatus_args()
1306 
    args.transactionId = transactionId
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_getTransactionStatus(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = getTransactionStatus_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
3431 rajveer 1321 
    if result.success is not None:
94 ashish 1322 
      return result.success
3431 rajveer 1323 
    if result.ex is not None:
94 ashish 1324 
      raise result.ex
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1326 
 
1327 
  def changeTransactionStatus(self, transactionId, status, description):
1328 
    """
1329 
    Parameters:
1330 
     - transactionId
1331 
     - status
1332 
     - description
1333 
    """
1334 
    self.send_changeTransactionStatus(transactionId, status, description)
1335 
    return self.recv_changeTransactionStatus()
1336 
 
1337 
  def send_changeTransactionStatus(self, transactionId, status, description):
1338 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1339 
    args = changeTransactionStatus_args()
1340 
    args.transactionId = transactionId
1341 
    args.status = status
1342 
    args.description = description
1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1347 
  def recv_changeTransactionStatus(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 = changeTransactionStatus_result()
1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
3431 rajveer 1357 
    if result.success is not None:
94 ashish 1358 
      return result.success
3431 rajveer 1359 
    if result.ex is not None:
94 ashish 1360 
      raise result.ex
1361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1362 
 
1398 varun.gupt 1363 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1364 
    """
1365 
    Parameters:
1366 
     - transactionId
1367 
    """
1398 varun.gupt 1368 
    self.send_enqueueTransactionInfoEmail(transactionId)
1369 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1370 
 
1398 varun.gupt 1371 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1372 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1373 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1374 
    args.transactionId = transactionId
1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1398 varun.gupt 1379 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 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
1398 varun.gupt 1386 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
3431 rajveer 1389 
    if result.success is not None:
1382 varun.gupt 1390 
      return result.success
3431 rajveer 1391 
    if result.ex is not None:
1382 varun.gupt 1392 
      raise result.ex
1398 varun.gupt 1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1394 
 
4801 anupam.sin 1395 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1396 
    """
1397 
    Parameters:
4801 anupam.sin 1398 
     - statuses
483 rajveer 1399 
     - from_date
1400 
     - to_date
1401 
     - warehouse_id
94 ashish 1402 
    """
4801 anupam.sin 1403 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1404 
    return self.recv_getAllOrders()
94 ashish 1405 
 
4801 anupam.sin 1406 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1407 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1408 
    args = getAllOrders_args()
4801 anupam.sin 1409 
    args.statuses = statuses
483 rajveer 1410 
    args.from_date = from_date
1411 
    args.to_date = to_date
1412 
    args.warehouse_id = warehouse_id
94 ashish 1413 
    args.write(self._oprot)
1414 
    self._oprot.writeMessageEnd()
1415 
    self._oprot.trans.flush()
1416 
 
483 rajveer 1417 
  def recv_getAllOrders(self, ):
94 ashish 1418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1419 
    if mtype == TMessageType.EXCEPTION:
1420 
      x = TApplicationException()
1421 
      x.read(self._iprot)
1422 
      self._iprot.readMessageEnd()
1423 
      raise x
483 rajveer 1424 
    result = getAllOrders_result()
94 ashish 1425 
    result.read(self._iprot)
1426 
    self._iprot.readMessageEnd()
3431 rajveer 1427 
    if result.success is not None:
94 ashish 1428 
      return result.success
3431 rajveer 1429 
    if result.ex is not None:
94 ashish 1430 
      raise result.ex
483 rajveer 1431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1432 
 
4133 chandransh 1433 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1434 
    """
1435 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1436 
    Pass the status as null and the limit as 0 to ignore them.
1437 
 
1438 
    Parameters:
1439 
     - statuses
1440 
     - offset
1441 
     - limit
1442 
     - warehouse_id
1443 
    """
1444 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1445 
    return self.recv_getOrdersInBatch()
1446 
 
1447 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1448 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1449 
    args = getOrdersInBatch_args()
1450 
    args.statuses = statuses
1451 
    args.offset = offset
1452 
    args.limit = limit
1453 
    args.warehouse_id = warehouse_id
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_getOrdersInBatch(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = getOrdersInBatch_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
1468 
    if result.success is not None:
1469 
      return result.success
1470 
    if result.ex is not None:
1471 
      raise result.ex
1472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1473 
 
1474 
  def getOrderCount(self, statuses, warehouseId):
1475 
    """
1476 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1477 
 
1478 
    Parameters:
1479 
     - statuses
1480 
     - warehouseId
1481 
    """
1482 
    self.send_getOrderCount(statuses, warehouseId)
1483 
    return self.recv_getOrderCount()
1484 
 
1485 
  def send_getOrderCount(self, statuses, warehouseId):
1486 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1487 
    args = getOrderCount_args()
1488 
    args.statuses = statuses
1489 
    args.warehouseId = warehouseId
1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
1494 
  def recv_getOrderCount(self, ):
1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
1501 
    result = getOrderCount_result()
1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
1504 
    if result.success is not None:
1505 
      return result.success
1506 
    if result.ex is not None:
1507 
      raise result.ex
1508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1509 
 
999 varun.gupt 1510 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1511 
    """
1132 chandransh 1512 
    Returns orders within a range of their billing dates
3431 rajveer 1513 
 
999 varun.gupt 1514 
    Parameters:
1515 
     - status
1516 
     - start_billing_date
1517 
     - end_billing_date
1518 
     - warehouse_id
1519 
    """
1520 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1521 
    return self.recv_getOrdersByBillingDate()
1522 
 
1523 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1524 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1525 
    args = getOrdersByBillingDate_args()
1526 
    args.status = status
1527 
    args.start_billing_date = start_billing_date
1528 
    args.end_billing_date = end_billing_date
1529 
    args.warehouse_id = warehouse_id
1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_getOrdersByBillingDate(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = getOrdersByBillingDate_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
3431 rajveer 1544 
    if result.success is not None:
999 varun.gupt 1545 
      return result.success
3431 rajveer 1546 
    if result.ex is not None:
999 varun.gupt 1547 
      raise result.ex
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1549 
 
3451 chandransh 1550 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1551 
    """
1552 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1553 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1554 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1555 
 
3427 chandransh 1556 
    Parameters:
1557 
     - fromShippingDate
1558 
     - toShippingDate
1559 
     - providerId
1560 
     - warehouseId
3451 chandransh 1561 
     - cod
3427 chandransh 1562 
    """
3451 chandransh 1563 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1564 
    return self.recv_getOrdersByShippingDate()
1565 
 
3451 chandransh 1566 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1567 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1568 
    args = getOrdersByShippingDate_args()
1569 
    args.fromShippingDate = fromShippingDate
1570 
    args.toShippingDate = toShippingDate
1571 
    args.providerId = providerId
1572 
    args.warehouseId = warehouseId
3451 chandransh 1573 
    args.cod = cod
3427 chandransh 1574 
    args.write(self._oprot)
1575 
    self._oprot.writeMessageEnd()
1576 
    self._oprot.trans.flush()
1577 
 
1578 
  def recv_getOrdersByShippingDate(self, ):
1579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1580 
    if mtype == TMessageType.EXCEPTION:
1581 
      x = TApplicationException()
1582 
      x.read(self._iprot)
1583 
      self._iprot.readMessageEnd()
1584 
      raise x
1585 
    result = getOrdersByShippingDate_result()
1586 
    result.read(self._iprot)
1587 
    self._iprot.readMessageEnd()
3431 rajveer 1588 
    if result.success is not None:
3427 chandransh 1589 
      return result.success
3431 rajveer 1590 
    if result.ex is not None:
3427 chandransh 1591 
      raise result.ex
1592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1593 
 
1382 varun.gupt 1594 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1595 
    """
1596 
    Returns order ids for orders which can be returned
3431 rajveer 1597 
 
1382 varun.gupt 1598 
    Parameters:
1599 
     - customer_id
1600 
     - limit
1601 
    """
1602 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1603 
    return self.recv_getReturnableOrdersForCustomer()
1604 
 
1605 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1606 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1607 
    args = getReturnableOrdersForCustomer_args()
1608 
    args.customer_id = customer_id
1609 
    args.limit = limit
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getReturnableOrdersForCustomer(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getReturnableOrdersForCustomer_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
3431 rajveer 1624 
    if result.success is not None:
1382 varun.gupt 1625 
      return result.success
3431 rajveer 1626 
    if result.ex is not None:
1382 varun.gupt 1627 
      raise result.ex
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1629 
 
1630 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1631 
    """
1632 
    Returns order ids for orders which can be cancelled
3431 rajveer 1633 
 
1382 varun.gupt 1634 
    Parameters:
1635 
     - customer_id
1636 
     - limit
1637 
    """
1638 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1639 
    return self.recv_getCancellableOrdersForCustomer()
1640 
 
1641 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1642 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1643 
    args = getCancellableOrdersForCustomer_args()
1644 
    args.customer_id = customer_id
1645 
    args.limit = limit
1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_getCancellableOrdersForCustomer(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 = getCancellableOrdersForCustomer_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
3431 rajveer 1660 
    if result.success is not None:
1382 varun.gupt 1661 
      return result.success
3431 rajveer 1662 
    if result.ex is not None:
1382 varun.gupt 1663 
      raise result.ex
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1665 
 
483 rajveer 1666 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1667 
    """
1668 
    Parameters:
483 rajveer 1669 
     - orderId
1670 
     - status
1671 
     - description
94 ashish 1672 
    """
483 rajveer 1673 
    self.send_changeOrderStatus(orderId, status, description)
1674 
    return self.recv_changeOrderStatus()
94 ashish 1675 
 
483 rajveer 1676 
  def send_changeOrderStatus(self, orderId, status, description):
1677 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1678 
    args = changeOrderStatus_args()
1679 
    args.orderId = orderId
1680 
    args.status = status
1681 
    args.description = description
94 ashish 1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
483 rajveer 1686 
  def recv_changeOrderStatus(self, ):
94 ashish 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
483 rajveer 1693 
    result = changeOrderStatus_result()
94 ashish 1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
3431 rajveer 1696 
    if result.success is not None:
94 ashish 1697 
      return result.success
3431 rajveer 1698 
    if result.ex is not None:
94 ashish 1699 
      raise result.ex
483 rajveer 1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1701 
 
1528 ankur.sing 1702 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1703 
    """
1528 ankur.sing 1704 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1705 
    only user who owns the transaction can view its order details.
3431 rajveer 1706 
 
94 ashish 1707 
    Parameters:
1708 
     - transactionId
1528 ankur.sing 1709 
     - customerId
94 ashish 1710 
    """
1528 ankur.sing 1711 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1712 
    return self.recv_getOrdersForTransaction()
94 ashish 1713 
 
1528 ankur.sing 1714 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1715 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1716 
    args = getOrdersForTransaction_args()
94 ashish 1717 
    args.transactionId = transactionId
1528 ankur.sing 1718 
    args.customerId = customerId
94 ashish 1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
483 rajveer 1723 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
483 rajveer 1730 
    result = getOrdersForTransaction_result()
94 ashish 1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
94 ashish 1734 
      return result.success
3431 rajveer 1735 
    if result.ex is not None:
94 ashish 1736 
      raise result.ex
483 rajveer 1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1738 
 
3014 chandransh 1739 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1740 
    """
3014 chandransh 1741 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1742 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1743 
 
94 ashish 1744 
    Parameters:
483 rajveer 1745 
     - customerId
1746 
     - from_date
1747 
     - to_date
3014 chandransh 1748 
     - statuses
94 ashish 1749 
    """
3014 chandransh 1750 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1751 
    return self.recv_getOrdersForCustomer()
94 ashish 1752 
 
3014 chandransh 1753 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1754 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1755 
    args = getOrdersForCustomer_args()
1756 
    args.customerId = customerId
1757 
    args.from_date = from_date
1758 
    args.to_date = to_date
3014 chandransh 1759 
    args.statuses = statuses
94 ashish 1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
483 rajveer 1764 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
483 rajveer 1771 
    result = getOrdersForCustomer_result()
94 ashish 1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
3431 rajveer 1774 
    if result.success is not None:
94 ashish 1775 
      return result.success
3431 rajveer 1776 
    if result.ex is not None:
94 ashish 1777 
      raise result.ex
483 rajveer 1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1779 
 
483 rajveer 1780 
  def createOrder(self, order):
94 ashish 1781 
    """
1782 
    Parameters:
483 rajveer 1783 
     - order
94 ashish 1784 
    """
483 rajveer 1785 
    self.send_createOrder(order)
1786 
    return self.recv_createOrder()
94 ashish 1787 
 
483 rajveer 1788 
  def send_createOrder(self, order):
1789 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1790 
    args = createOrder_args()
1791 
    args.order = order
94 ashish 1792 
    args.write(self._oprot)
1793 
    self._oprot.writeMessageEnd()
1794 
    self._oprot.trans.flush()
1795 
 
483 rajveer 1796 
  def recv_createOrder(self, ):
94 ashish 1797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1798 
    if mtype == TMessageType.EXCEPTION:
1799 
      x = TApplicationException()
1800 
      x.read(self._iprot)
1801 
      self._iprot.readMessageEnd()
1802 
      raise x
483 rajveer 1803 
    result = createOrder_result()
94 ashish 1804 
    result.read(self._iprot)
1805 
    self._iprot.readMessageEnd()
3431 rajveer 1806 
    if result.success is not None:
94 ashish 1807 
      return result.success
3431 rajveer 1808 
    if result.ex is not None:
94 ashish 1809 
      raise result.ex
483 rajveer 1810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1811 
 
483 rajveer 1812 
  def getOrder(self, id):
94 ashish 1813 
    """
1814 
    Parameters:
483 rajveer 1815 
     - id
94 ashish 1816 
    """
483 rajveer 1817 
    self.send_getOrder(id)
1818 
    return self.recv_getOrder()
94 ashish 1819 
 
483 rajveer 1820 
  def send_getOrder(self, id):
1821 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1822 
    args = getOrder_args()
1823 
    args.id = id
94 ashish 1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
483 rajveer 1828 
  def recv_getOrder(self, ):
94 ashish 1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
483 rajveer 1835 
    result = getOrder_result()
94 ashish 1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
3431 rajveer 1838 
    if result.success is not None:
94 ashish 1839 
      return result.success
3431 rajveer 1840 
    if result.ex is not None:
94 ashish 1841 
      raise result.ex
483 rajveer 1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1843 
 
483 rajveer 1844 
  def getLineItemsForOrder(self, orderId):
94 ashish 1845 
    """
1846 
    Parameters:
483 rajveer 1847 
     - orderId
94 ashish 1848 
    """
483 rajveer 1849 
    self.send_getLineItemsForOrder(orderId)
1850 
    return self.recv_getLineItemsForOrder()
94 ashish 1851 
 
483 rajveer 1852 
  def send_getLineItemsForOrder(self, orderId):
1853 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1854 
    args = getLineItemsForOrder_args()
1855 
    args.orderId = orderId
94 ashish 1856 
    args.write(self._oprot)
1857 
    self._oprot.writeMessageEnd()
1858 
    self._oprot.trans.flush()
1859 
 
483 rajveer 1860 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1862 
    if mtype == TMessageType.EXCEPTION:
1863 
      x = TApplicationException()
1864 
      x.read(self._iprot)
1865 
      self._iprot.readMessageEnd()
1866 
      raise x
483 rajveer 1867 
    result = getLineItemsForOrder_result()
94 ashish 1868 
    result.read(self._iprot)
1869 
    self._iprot.readMessageEnd()
3431 rajveer 1870 
    if result.success is not None:
94 ashish 1871 
      return result.success
3431 rajveer 1872 
    if result.ex is not None:
94 ashish 1873 
      raise result.ex
483 rajveer 1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1875 
 
4999 phani.kuma 1876 
  def getOrderList(self, order_ids):
1877 
    """
1878 
    Parameters:
1879 
     - order_ids
1880 
    """
1881 
    self.send_getOrderList(order_ids)
1882 
    return self.recv_getOrderList()
1883 
 
1884 
  def send_getOrderList(self, order_ids):
1885 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1886 
    args = getOrderList_args()
1887 
    args.order_ids = order_ids
1888 
    args.write(self._oprot)
1889 
    self._oprot.writeMessageEnd()
1890 
    self._oprot.trans.flush()
1891 
 
1892 
  def recv_getOrderList(self, ):
1893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1894 
    if mtype == TMessageType.EXCEPTION:
1895 
      x = TApplicationException()
1896 
      x.read(self._iprot)
1897 
      self._iprot.readMessageEnd()
1898 
      raise x
1899 
    result = getOrderList_result()
1900 
    result.read(self._iprot)
1901 
    self._iprot.readMessageEnd()
1902 
    if result.success is not None:
1903 
      return result.success
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1905 
 
5386 phani.kuma 1906 
  def getOrderListForVendor(self, order_ids, vendorId):
1907 
    """
1908 
    Parameters:
1909 
     - order_ids
1910 
     - vendorId
1911 
    """
1912 
    self.send_getOrderListForVendor(order_ids, vendorId)
1913 
    return self.recv_getOrderListForVendor()
1914 
 
1915 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1916 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1917 
    args = getOrderListForVendor_args()
1918 
    args.order_ids = order_ids
1919 
    args.vendorId = vendorId
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_getOrderListForVendor(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = getOrderListForVendor_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
1934 
    if result.success is not None:
1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
1937 
 
1528 ankur.sing 1938 
  def getOrderForCustomer(self, orderId, customerId):
1939 
    """
1940 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1941 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1942 
 
1528 ankur.sing 1943 
    Parameters:
1944 
     - orderId
1945 
     - customerId
1946 
    """
1947 
    self.send_getOrderForCustomer(orderId, customerId)
1948 
    return self.recv_getOrderForCustomer()
1949 
 
1950 
  def send_getOrderForCustomer(self, orderId, customerId):
1951 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1952 
    args = getOrderForCustomer_args()
1953 
    args.orderId = orderId
1954 
    args.customerId = customerId
1955 
    args.write(self._oprot)
1956 
    self._oprot.writeMessageEnd()
1957 
    self._oprot.trans.flush()
1958 
 
1959 
  def recv_getOrderForCustomer(self, ):
1960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1961 
    if mtype == TMessageType.EXCEPTION:
1962 
      x = TApplicationException()
1963 
      x.read(self._iprot)
1964 
      self._iprot.readMessageEnd()
1965 
      raise x
1966 
    result = getOrderForCustomer_result()
1967 
    result.read(self._iprot)
1968 
    self._iprot.readMessageEnd()
3431 rajveer 1969 
    if result.success is not None:
1528 ankur.sing 1970 
      return result.success
3431 rajveer 1971 
    if result.ex is not None:
1528 ankur.sing 1972 
      raise result.ex
1973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1974 
 
4444 rajveer 1975 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1976 
    """
1977 
    Parameters:
4394 rajveer 1978 
     - type
4444 rajveer 1979 
     - warehouseId
4394 rajveer 1980 
     - status
1981 
     - timestamp
3064 chandransh 1982 
    """
4444 rajveer 1983 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1984 
    return self.recv_getAlerts()
1985 
 
4444 rajveer 1986 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1987 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1988 
    args = getAlerts_args()
4394 rajveer 1989 
    args.type = type
4444 rajveer 1990 
    args.warehouseId = warehouseId
4394 rajveer 1991 
    args.status = status
1992 
    args.timestamp = timestamp
3064 chandransh 1993 
    args.write(self._oprot)
1994 
    self._oprot.writeMessageEnd()
1995 
    self._oprot.trans.flush()
1996 
 
1997 
  def recv_getAlerts(self, ):
1998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1999 
    if mtype == TMessageType.EXCEPTION:
2000 
      x = TApplicationException()
2001 
      x.read(self._iprot)
2002 
      self._iprot.readMessageEnd()
2003 
      raise x
2004 
    result = getAlerts_result()
2005 
    result.read(self._iprot)
2006 
    self._iprot.readMessageEnd()
3431 rajveer 2007 
    if result.success is not None:
3064 chandransh 2008 
      return result.success
2009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2010 
 
4444 rajveer 2011 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2012 
    """
2013 
    Parameters:
2014 
     - type
4444 rajveer 2015 
     - warehouseId
4394 rajveer 2016 
     - description
3064 chandransh 2017 
    """
4444 rajveer 2018 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2019 
    self.recv_addAlert()
3064 chandransh 2020 
 
4444 rajveer 2021 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2022 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2023 
    args = addAlert_args()
3064 chandransh 2024 
    args.type = type
4444 rajveer 2025 
    args.warehouseId = warehouseId
4394 rajveer 2026 
    args.description = description
3064 chandransh 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
4394 rajveer 2031 
  def recv_addAlert(self, ):
3064 chandransh 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
4394 rajveer 2038 
    result = addAlert_result()
3064 chandransh 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
2041 
    return
2042 
 
4444 rajveer 2043 
  def markAlertsAsSeen(self, warehouseId):
2044 
    """
2045 
    Parameters:
2046 
     - warehouseId
2047 
    """
2048 
    self.send_markAlertsAsSeen(warehouseId)
2049 
    self.recv_markAlertsAsSeen()
2050 
 
2051 
  def send_markAlertsAsSeen(self, warehouseId):
2052 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2053 
    args = markAlertsAsSeen_args()
2054 
    args.warehouseId = warehouseId
2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
2059 
  def recv_markAlertsAsSeen(self, ):
2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
2066 
    result = markAlertsAsSeen_result()
2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
2069 
    return
2070 
 
3064 chandransh 2071 
  def getValidOrderCount(self, ):
2072 
    """
2073 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2074 
    """
2075 
    self.send_getValidOrderCount()
2076 
    return self.recv_getValidOrderCount()
2077 
 
2078 
  def send_getValidOrderCount(self, ):
2079 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2080 
    args = getValidOrderCount_args()
2081 
    args.write(self._oprot)
2082 
    self._oprot.writeMessageEnd()
2083 
    self._oprot.trans.flush()
2084 
 
2085 
  def recv_getValidOrderCount(self, ):
2086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2087 
    if mtype == TMessageType.EXCEPTION:
2088 
      x = TApplicationException()
2089 
      x.read(self._iprot)
2090 
      self._iprot.readMessageEnd()
2091 
      raise x
2092 
    result = getValidOrderCount_result()
2093 
    result.read(self._iprot)
2094 
    self._iprot.readMessageEnd()
3431 rajveer 2095 
    if result.success is not None:
3064 chandransh 2096 
      return result.success
2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2098 
 
2099 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2100 
    """
2101 
    Returns the number of distinct customers who have done successful transactions
2102 
    """
2103 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2104 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2105 
 
2106 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2107 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2108 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
2113 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
2120 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
3064 chandransh 2124 
      return result.success
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2126 
 
2127 
  def getValidOrdersAmountRange(self, ):
2128 
    """
2129 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2130 
    List contains two values, first minimum amount and second maximum amount.
2131 
    """
2132 
    self.send_getValidOrdersAmountRange()
2133 
    return self.recv_getValidOrdersAmountRange()
2134 
 
2135 
  def send_getValidOrdersAmountRange(self, ):
2136 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2137 
    args = getValidOrdersAmountRange_args()
2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
2142 
  def recv_getValidOrdersAmountRange(self, ):
2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
2149 
    result = getValidOrdersAmountRange_result()
2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
3431 rajveer 2152 
    if result.success is not None:
3064 chandransh 2153 
      return result.success
2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2155 
 
2156 
  def getValidOrders(self, limit):
2157 
    """
2158 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2159 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2160 
 
3064 chandransh 2161 
    Parameters:
2162 
     - limit
2163 
    """
2164 
    self.send_getValidOrders(limit)
2165 
    return self.recv_getValidOrders()
2166 
 
2167 
  def send_getValidOrders(self, limit):
2168 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2169 
    args = getValidOrders_args()
2170 
    args.limit = limit
2171 
    args.write(self._oprot)
2172 
    self._oprot.writeMessageEnd()
2173 
    self._oprot.trans.flush()
2174 
 
2175 
  def recv_getValidOrders(self, ):
2176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2177 
    if mtype == TMessageType.EXCEPTION:
2178 
      x = TApplicationException()
2179 
      x.read(self._iprot)
2180 
      self._iprot.readMessageEnd()
2181 
      raise x
2182 
    result = getValidOrders_result()
2183 
    result.read(self._iprot)
2184 
    self._iprot.readMessageEnd()
3431 rajveer 2185 
    if result.success is not None:
3064 chandransh 2186 
      return result.success
2187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2188 
 
1220 chandransh 2189 
  def batchOrders(self, warehouseId):
2190 
    """
2191 
    Create a batch of all the pending orders for the given warehouse.
2192 
    The returned list is orderd by created_timestamp.
2193 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2194 
 
1220 chandransh 2195 
    Parameters:
2196 
     - warehouseId
2197 
    """
2198 
    self.send_batchOrders(warehouseId)
2199 
    return self.recv_batchOrders()
2200 
 
2201 
  def send_batchOrders(self, warehouseId):
2202 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2203 
    args = batchOrders_args()
2204 
    args.warehouseId = warehouseId
2205 
    args.write(self._oprot)
2206 
    self._oprot.writeMessageEnd()
2207 
    self._oprot.trans.flush()
2208 
 
2209 
  def recv_batchOrders(self, ):
2210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2211 
    if mtype == TMessageType.EXCEPTION:
2212 
      x = TApplicationException()
2213 
      x.read(self._iprot)
2214 
      self._iprot.readMessageEnd()
2215 
      raise x
2216 
    result = batchOrders_result()
2217 
    result.read(self._iprot)
2218 
    self._iprot.readMessageEnd()
3431 rajveer 2219 
    if result.success is not None:
1220 chandransh 2220 
      return result.success
3431 rajveer 2221 
    if result.ex is not None:
1220 chandransh 2222 
      raise result.ex
2223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2224 
 
1208 chandransh 2225 
  def markOrderAsOutOfStock(self, orderId):
2226 
    """
2227 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2228 
 
1208 chandransh 2229 
    Parameters:
2230 
     - orderId
2231 
    """
2232 
    self.send_markOrderAsOutOfStock(orderId)
2233 
    return self.recv_markOrderAsOutOfStock()
2234 
 
2235 
  def send_markOrderAsOutOfStock(self, orderId):
2236 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2237 
    args = markOrderAsOutOfStock_args()
2238 
    args.orderId = orderId
2239 
    args.write(self._oprot)
2240 
    self._oprot.writeMessageEnd()
2241 
    self._oprot.trans.flush()
2242 
 
2243 
  def recv_markOrderAsOutOfStock(self, ):
2244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2245 
    if mtype == TMessageType.EXCEPTION:
2246 
      x = TApplicationException()
2247 
      x.read(self._iprot)
2248 
      self._iprot.readMessageEnd()
2249 
      raise x
2250 
    result = markOrderAsOutOfStock_result()
2251 
    result.read(self._iprot)
2252 
    self._iprot.readMessageEnd()
3431 rajveer 2253 
    if result.success is not None:
1208 chandransh 2254 
      return result.success
3431 rajveer 2255 
    if result.ex is not None:
1208 chandransh 2256 
      raise result.ex
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2258 
 
3064 chandransh 2259 
  def verifyOrder(self, orderId):
759 chandransh 2260 
    """
3064 chandransh 2261 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2262 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2263 
    used for all other orders as well.
2264 
    Throws an exception if no such order exists.
3431 rajveer 2265 
 
759 chandransh 2266 
    Parameters:
3064 chandransh 2267 
     - orderId
759 chandransh 2268 
    """
3064 chandransh 2269 
    self.send_verifyOrder(orderId)
2270 
    return self.recv_verifyOrder()
759 chandransh 2271 
 
3064 chandransh 2272 
  def send_verifyOrder(self, orderId):
2273 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2274 
    args = verifyOrder_args()
2275 
    args.orderId = orderId
759 chandransh 2276 
    args.write(self._oprot)
2277 
    self._oprot.writeMessageEnd()
2278 
    self._oprot.trans.flush()
2279 
 
3064 chandransh 2280 
  def recv_verifyOrder(self, ):
759 chandransh 2281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2282 
    if mtype == TMessageType.EXCEPTION:
2283 
      x = TApplicationException()
2284 
      x.read(self._iprot)
2285 
      self._iprot.readMessageEnd()
2286 
      raise x
3064 chandransh 2287 
    result = verifyOrder_result()
759 chandransh 2288 
    result.read(self._iprot)
2289 
    self._iprot.readMessageEnd()
3431 rajveer 2290 
    if result.success is not None:
759 chandransh 2291 
      return result.success
3431 rajveer 2292 
    if result.ex is not None:
759 chandransh 2293 
      raise result.ex
3064 chandransh 2294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2295 
 
3064 chandransh 2296 
  def acceptOrder(self, orderId):
1113 chandransh 2297 
    """
3064 chandransh 2298 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2299 
    given order is not a COD order, it also captures the payment if the same has
2300 
    not been captured.
2301 
    Throws an exception if no such order exists.
3431 rajveer 2302 
 
1113 chandransh 2303 
    Parameters:
3064 chandransh 2304 
     - orderId
1113 chandransh 2305 
    """
3064 chandransh 2306 
    self.send_acceptOrder(orderId)
2307 
    return self.recv_acceptOrder()
1113 chandransh 2308 
 
3064 chandransh 2309 
  def send_acceptOrder(self, orderId):
2310 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2311 
    args = acceptOrder_args()
2312 
    args.orderId = orderId
1113 chandransh 2313 
    args.write(self._oprot)
2314 
    self._oprot.writeMessageEnd()
2315 
    self._oprot.trans.flush()
2316 
 
3064 chandransh 2317 
  def recv_acceptOrder(self, ):
1113 chandransh 2318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2319 
    if mtype == TMessageType.EXCEPTION:
2320 
      x = TApplicationException()
2321 
      x.read(self._iprot)
2322 
      self._iprot.readMessageEnd()
2323 
      raise x
3064 chandransh 2324 
    result = acceptOrder_result()
1113 chandransh 2325 
    result.read(self._iprot)
2326 
    self._iprot.readMessageEnd()
3431 rajveer 2327 
    if result.success is not None:
1113 chandransh 2328 
      return result.success
3431 rajveer 2329 
    if result.ex is not None:
1113 chandransh 2330 
      raise result.ex
3064 chandransh 2331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2332 
 
5110 mandeep.dh 2333 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2334 
    """
3064 chandransh 2335 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2336 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2337 
    the IMEI no. if a -1 is supplied.
2338 
    Also, it generates an invoice number for the order, marks the order as
2339 
    BILLED and sets the billing timestamp.
2340 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2341 
 
1135 chandransh 2342 
    Parameters:
3064 chandransh 2343 
     - orderId
2344 
     - invoice_number
4658 mandeep.dh 2345 
     - serialNumber
4283 anupam.sin 2346 
     - itemNumber
3064 chandransh 2347 
     - billed_by
4264 rajveer 2348 
     - jacketNumber
4283 anupam.sin 2349 
     - billingType
5110 mandeep.dh 2350 
     - fulfilmentWarehouseId
4763 rajveer 2351 
     - authorize
1135 chandransh 2352 
    """
5110 mandeep.dh 2353 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2354 
    return self.recv_addBillingDetails()
1135 chandransh 2355 
 
5110 mandeep.dh 2356 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2357 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2358 
    args = addBillingDetails_args()
2359 
    args.orderId = orderId
2360 
    args.invoice_number = invoice_number
4658 mandeep.dh 2361 
    args.serialNumber = serialNumber
4283 anupam.sin 2362 
    args.itemNumber = itemNumber
3064 chandransh 2363 
    args.billed_by = billed_by
4264 rajveer 2364 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2365 
    args.billingType = billingType
5110 mandeep.dh 2366 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2367 
    args.authorize = authorize
1135 chandransh 2368 
    args.write(self._oprot)
2369 
    self._oprot.writeMessageEnd()
2370 
    self._oprot.trans.flush()
2371 
 
3064 chandransh 2372 
  def recv_addBillingDetails(self, ):
1135 chandransh 2373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2374 
    if mtype == TMessageType.EXCEPTION:
2375 
      x = TApplicationException()
2376 
      x.read(self._iprot)
2377 
      self._iprot.readMessageEnd()
2378 
      raise x
3064 chandransh 2379 
    result = addBillingDetails_result()
1135 chandransh 2380 
    result.read(self._iprot)
2381 
    self._iprot.readMessageEnd()
3431 rajveer 2382 
    if result.success is not None:
3064 chandransh 2383 
      return result.success
3431 rajveer 2384 
    if result.ex is not None:
1135 chandransh 2385 
      raise result.ex
3064 chandransh 2386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2387 
 
4763 rajveer 2388 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2389 
    """
2390 
    Add the invoice number to the order.
2391 
 
2392 
    Parameters:
2393 
     - orderId
2394 
     - invoiceNumber
4763 rajveer 2395 
     - color
4579 rajveer 2396 
    """
4763 rajveer 2397 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2398 
    self.recv_addInvoiceNumber()
2399 
 
4763 rajveer 2400 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2401 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2402 
    args = addInvoiceNumber_args()
2403 
    args.orderId = orderId
2404 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2405 
    args.color = color
4579 rajveer 2406 
    args.write(self._oprot)
2407 
    self._oprot.writeMessageEnd()
2408 
    self._oprot.trans.flush()
2409 
 
2410 
  def recv_addInvoiceNumber(self, ):
2411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2412 
    if mtype == TMessageType.EXCEPTION:
2413 
      x = TApplicationException()
2414 
      x.read(self._iprot)
2415 
      self._iprot.readMessageEnd()
2416 
      raise x
2417 
    result = addInvoiceNumber_result()
2418 
    result.read(self._iprot)
2419 
    self._iprot.readMessageEnd()
2420 
    if result.ex is not None:
2421 
      raise result.ex
2422 
    return
2423 
 
4910 phani.kuma 2424 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2425 
    """
3064 chandransh 2426 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2427 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2428 
 
1408 ankur.sing 2429 
    Parameters:
3064 chandransh 2430 
     - warehouseId
1408 ankur.sing 2431 
     - providerId
3064 chandransh 2432 
     - cod
4910 phani.kuma 2433 
     - orderIds
1408 ankur.sing 2434 
    """
4910 phani.kuma 2435 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2436 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2437 
 
4910 phani.kuma 2438 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2439 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2440 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2441 
    args.warehouseId = warehouseId
1408 ankur.sing 2442 
    args.providerId = providerId
3064 chandransh 2443 
    args.cod = cod
4910 phani.kuma 2444 
    args.orderIds = orderIds
1408 ankur.sing 2445 
    args.write(self._oprot)
2446 
    self._oprot.writeMessageEnd()
2447 
    self._oprot.trans.flush()
2448 
 
4910 phani.kuma 2449 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2451 
    if mtype == TMessageType.EXCEPTION:
2452 
      x = TApplicationException()
2453 
      x.read(self._iprot)
2454 
      self._iprot.readMessageEnd()
2455 
      raise x
4910 phani.kuma 2456 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2457 
    result.read(self._iprot)
2458 
    self._iprot.readMessageEnd()
3431 rajveer 2459 
    if result.success is not None:
1408 ankur.sing 2460 
      return result.success
3431 rajveer 2461 
    if result.ex is not None:
3064 chandransh 2462 
      raise result.ex
4910 phani.kuma 2463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2464 
 
4910 phani.kuma 2465 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2466 
    """
4910 phani.kuma 2467 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2468 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2469 
 
2470 
    Parameters:
2471 
     - providerId
4910 phani.kuma 2472 
     - pickupDetails
4410 rajveer 2473 
    """
4910 phani.kuma 2474 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2475 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2476 
 
4910 phani.kuma 2477 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2478 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2479 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2480 
    args.providerId = providerId
4910 phani.kuma 2481 
    args.pickupDetails = pickupDetails
4410 rajveer 2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
4910 phani.kuma 2486 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
4910 phani.kuma 2493 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
2496 
    if result.ex is not None:
2497 
      raise result.ex
4910 phani.kuma 2498 
    return
4410 rajveer 2499 
 
4910 phani.kuma 2500 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2501 
    """
3064 chandransh 2502 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2503 
 
94 ashish 2504 
    Parameters:
3064 chandransh 2505 
     - providerId
304 ashish 2506 
    """
4910 phani.kuma 2507 
    self.send_getOrdersNotPickedUp(providerId)
2508 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2509 
 
4910 phani.kuma 2510 
  def send_getOrdersNotPickedUp(self, providerId):
2511 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2512 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2513 
    args.providerId = providerId
304 ashish 2514 
    args.write(self._oprot)
2515 
    self._oprot.writeMessageEnd()
2516 
    self._oprot.trans.flush()
2517 
 
4910 phani.kuma 2518 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2520 
    if mtype == TMessageType.EXCEPTION:
2521 
      x = TApplicationException()
2522 
      x.read(self._iprot)
2523 
      self._iprot.readMessageEnd()
2524 
      raise x
4910 phani.kuma 2525 
    result = getOrdersNotPickedUp_result()
304 ashish 2526 
    result.read(self._iprot)
2527 
    self._iprot.readMessageEnd()
3431 rajveer 2528 
    if result.success is not None:
304 ashish 2529 
      return result.success
4910 phani.kuma 2530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2531 
 
3064 chandransh 2532 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2533 
    """
3064 chandransh 2534 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2535 
    the name of the receiver.
2536 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2537 
 
304 ashish 2538 
    Parameters:
3064 chandransh 2539 
     - providerId
2540 
     - deliveredOrders
304 ashish 2541 
    """
3064 chandransh 2542 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2543 
    self.recv_markOrdersAsDelivered()
304 ashish 2544 
 
3064 chandransh 2545 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2546 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2547 
    args = markOrdersAsDelivered_args()
2548 
    args.providerId = providerId
2549 
    args.deliveredOrders = deliveredOrders
304 ashish 2550 
    args.write(self._oprot)
2551 
    self._oprot.writeMessageEnd()
2552 
    self._oprot.trans.flush()
2553 
 
3064 chandransh 2554 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2556 
    if mtype == TMessageType.EXCEPTION:
2557 
      x = TApplicationException()
2558 
      x.read(self._iprot)
2559 
      self._iprot.readMessageEnd()
2560 
      raise x
3064 chandransh 2561 
    result = markOrdersAsDelivered_result()
304 ashish 2562 
    result.read(self._iprot)
2563 
    self._iprot.readMessageEnd()
3431 rajveer 2564 
    if result.ex is not None:
3064 chandransh 2565 
      raise result.ex
304 ashish 2566 
    return
2567 
 
4910 phani.kuma 2568 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2569 
    """
4910 phani.kuma 2570 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2571 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2572 
 
3064 chandransh 2573 
    Parameters:
2574 
     - providerId
2575 
     - returnedOrders
1596 ankur.sing 2576 
    """
4910 phani.kuma 2577 
    self.send_markAsRTOrders(providerId, returnedOrders)
2578 
    self.recv_markAsRTOrders()
304 ashish 2579 
 
4910 phani.kuma 2580 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2581 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2582 
    args = markAsRTOrders_args()
3064 chandransh 2583 
    args.providerId = providerId
2584 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
4910 phani.kuma 2589 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
4910 phani.kuma 2596 
    result = markAsRTOrders_result()
1596 ankur.sing 2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
3431 rajveer 2599 
    if result.ex is not None:
3064 chandransh 2600 
      raise result.ex
2601 
    return
1596 ankur.sing 2602 
 
4910 phani.kuma 2603 
  def getRTOrders(self, providerId):
2604 
    """
2605 
    Returns a list of orders that were returned by courier.
2606 
 
2607 
    Parameters:
2608 
     - providerId
2609 
    """
2610 
    self.send_getRTOrders(providerId)
2611 
    return self.recv_getRTOrders()
2612 
 
2613 
  def send_getRTOrders(self, providerId):
2614 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2615 
    args = getRTOrders_args()
2616 
    args.providerId = providerId
2617 
    args.write(self._oprot)
2618 
    self._oprot.writeMessageEnd()
2619 
    self._oprot.trans.flush()
2620 
 
2621 
  def recv_getRTOrders(self, ):
2622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2623 
    if mtype == TMessageType.EXCEPTION:
2624 
      x = TApplicationException()
2625 
      x.read(self._iprot)
2626 
      self._iprot.readMessageEnd()
2627 
      raise x
2628 
    result = getRTOrders_result()
2629 
    result.read(self._iprot)
2630 
    self._iprot.readMessageEnd()
2631 
    if result.success is not None:
2632 
      return result.success
2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2634 
 
3064 chandransh 2635 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2636 
    """
3064 chandransh 2637 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2638 
 
3064 chandransh 2639 
    Parameters:
2640 
     - providerId
2641 
     - undeliveredOrders
1627 ankur.sing 2642 
    """
3064 chandransh 2643 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2644 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2645 
 
3064 chandransh 2646 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2647 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2648 
    args = updateNonDeliveryReason_args()
2649 
    args.providerId = providerId
2650 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
3064 chandransh 2655 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
3064 chandransh 2662 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
4910 phani.kuma 2665 
    if result.ex is not None:
2666 
      raise result.ex
2667 
    return
2668 
 
2669 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2670 
    """
2671 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2672 
 
2673 
    Parameters:
2674 
     - providerId
2675 
    """
2676 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2677 
    return self.recv_getNonDeliveredOrdersbyCourier()
2678 
 
2679 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2680 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2681 
    args = getNonDeliveredOrdersbyCourier_args()
2682 
    args.providerId = providerId
2683 
    args.write(self._oprot)
2684 
    self._oprot.writeMessageEnd()
2685 
    self._oprot.trans.flush()
2686 
 
2687 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2689 
    if mtype == TMessageType.EXCEPTION:
2690 
      x = TApplicationException()
2691 
      x.read(self._iprot)
2692 
      self._iprot.readMessageEnd()
2693 
      raise x
2694 
    result = getNonDeliveredOrdersbyCourier_result()
2695 
    result.read(self._iprot)
2696 
    self._iprot.readMessageEnd()
4581 phani.kuma 2697 
    if result.success is not None:
2698 
      return result.success
4910 phani.kuma 2699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2700 
 
2701 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2702 
    """
2703 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2704 
 
2705 
    Parameters:
2706 
     - providerId
2707 
     - local_connected_orders
2708 
    """
2709 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2710 
    self.recv_markOrdersAsLocalConnected()
2711 
 
2712 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2713 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2714 
    args = markOrdersAsLocalConnected_args()
2715 
    args.providerId = providerId
2716 
    args.local_connected_orders = local_connected_orders
2717 
    args.write(self._oprot)
2718 
    self._oprot.writeMessageEnd()
2719 
    self._oprot.trans.flush()
2720 
 
2721 
  def recv_markOrdersAsLocalConnected(self, ):
2722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2723 
    if mtype == TMessageType.EXCEPTION:
2724 
      x = TApplicationException()
2725 
      x.read(self._iprot)
2726 
      self._iprot.readMessageEnd()
2727 
      raise x
2728 
    result = markOrdersAsLocalConnected_result()
2729 
    result.read(self._iprot)
2730 
    self._iprot.readMessageEnd()
3431 rajveer 2731 
    if result.ex is not None:
3064 chandransh 2732 
      raise result.ex
4910 phani.kuma 2733 
    return
1627 ankur.sing 2734 
 
4910 phani.kuma 2735 
  def getOrdersNotLocalConnected(self, providerId):
2736 
    """
2737 
    Returns a list of orders that were picked up or shipped but pending local connection.
2738 
 
2739 
    Parameters:
2740 
     - providerId
2741 
    """
2742 
    self.send_getOrdersNotLocalConnected(providerId)
2743 
    return self.recv_getOrdersNotLocalConnected()
2744 
 
2745 
  def send_getOrdersNotLocalConnected(self, providerId):
2746 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2747 
    args = getOrdersNotLocalConnected_args()
2748 
    args.providerId = providerId
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_getOrdersNotLocalConnected(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = getOrdersNotLocalConnected_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.success is not None:
2764 
      return result.success
2765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2766 
 
2767 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2768 
    """
2769 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2770 
 
2771 
    Parameters:
2772 
     - providerId
2773 
     - destination_city_reached_orders
2774 
    """
2775 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2776 
    self.recv_markOrdersAsDestinationCityReached()
2777 
 
2778 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2779 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2780 
    args = markOrdersAsDestinationCityReached_args()
2781 
    args.providerId = providerId
2782 
    args.destination_city_reached_orders = destination_city_reached_orders
2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
2787 
  def recv_markOrdersAsDestinationCityReached(self, ):
2788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2789 
    if mtype == TMessageType.EXCEPTION:
2790 
      x = TApplicationException()
2791 
      x.read(self._iprot)
2792 
      self._iprot.readMessageEnd()
2793 
      raise x
2794 
    result = markOrdersAsDestinationCityReached_result()
2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
2797 
    if result.ex is not None:
2798 
      raise result.ex
2799 
    return
2800 
 
2801 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2802 
    """
2803 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2804 
 
2805 
    Parameters:
2806 
     - providerId
2807 
     - first_atdl_orders
2808 
    """
2809 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2810 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2811 
 
2812 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2813 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2814 
    args = markOrdersAsFirstDeliveryAttempted_args()
2815 
    args.providerId = providerId
2816 
    args.first_atdl_orders = first_atdl_orders
2817 
    args.write(self._oprot)
2818 
    self._oprot.writeMessageEnd()
2819 
    self._oprot.trans.flush()
2820 
 
2821 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2823 
    if mtype == TMessageType.EXCEPTION:
2824 
      x = TApplicationException()
2825 
      x.read(self._iprot)
2826 
      self._iprot.readMessageEnd()
2827 
      raise x
2828 
    result = markOrdersAsFirstDeliveryAttempted_result()
2829 
    result.read(self._iprot)
2830 
    self._iprot.readMessageEnd()
2831 
    if result.ex is not None:
2832 
      raise result.ex
2833 
    return
2834 
 
3064 chandransh 2835 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2836 
    """
3064 chandransh 2837 
    Returns the list of orders whose delivery time has passed but have not been
2838 
    delivered yet for the given provider and warehouse. To get a complete list of
2839 
    undelivered orders, pass them as -1.
2840 
    Returns an empty list if no such orders exist.
3431 rajveer 2841 
 
1886 ankur.sing 2842 
    Parameters:
3064 chandransh 2843 
     - providerId
2844 
     - warehouseId
1886 ankur.sing 2845 
    """
3064 chandransh 2846 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2847 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2848 
 
3064 chandransh 2849 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2850 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2851 
    args = getUndeliveredOrders_args()
2852 
    args.providerId = providerId
2853 
    args.warehouseId = warehouseId
1886 ankur.sing 2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
3064 chandransh 2858 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
3064 chandransh 2865 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
3431 rajveer 2868 
    if result.success is not None:
1886 ankur.sing 2869 
      return result.success
3064 chandransh 2870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2871 
 
4783 phani.kuma 2872 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2873 
    """
2874 
    Returns the list of orders whose expected delivery date has passed but have not been
2875 
    delivered yet.
2876 
    Returns an empty list if no such orders exist.
2877 
    """
2878 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2879 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2880 
 
2881 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2882 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2883 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2884 
    args.write(self._oprot)
2885 
    self._oprot.writeMessageEnd()
2886 
    self._oprot.trans.flush()
2887 
 
2888 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2890 
    if mtype == TMessageType.EXCEPTION:
2891 
      x = TApplicationException()
2892 
      x.read(self._iprot)
2893 
      self._iprot.readMessageEnd()
2894 
      raise x
2895 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2896 
    result.read(self._iprot)
2897 
    self._iprot.readMessageEnd()
2898 
    if result.success is not None:
2899 
      return result.success
2900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2901 
 
2536 chandransh 2902 
  def toggleDOAFlag(self, orderId):
2903 
    """
2904 
    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.
2905 
    Returns the final flag status.
2906 
    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 2907 
 
2536 chandransh 2908 
    Parameters:
2909 
     - orderId
2910 
    """
2911 
    self.send_toggleDOAFlag(orderId)
2912 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2913 
 
2536 chandransh 2914 
  def send_toggleDOAFlag(self, orderId):
2915 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2916 
    args = toggleDOAFlag_args()
2917 
    args.orderId = orderId
2918 
    args.write(self._oprot)
2919 
    self._oprot.writeMessageEnd()
2920 
    self._oprot.trans.flush()
2921 
 
2922 
  def recv_toggleDOAFlag(self, ):
2923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2924 
    if mtype == TMessageType.EXCEPTION:
2925 
      x = TApplicationException()
2926 
      x.read(self._iprot)
2927 
      self._iprot.readMessageEnd()
2928 
      raise x
2929 
    result = toggleDOAFlag_result()
2930 
    result.read(self._iprot)
2931 
    self._iprot.readMessageEnd()
3431 rajveer 2932 
    if result.success is not None:
2536 chandransh 2933 
      return result.success
3431 rajveer 2934 
    if result.ex is not None:
2536 chandransh 2935 
      raise result.ex
2936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2937 
 
4712 rajveer 2938 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2939 
    """
2940 
    Parameters:
2941 
     - orderId
2942 
     - deliveryTimestamp
2943 
     - receiver
2944 
    """
2945 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2946 
    self.recv_markOrderAsDelivered()
2947 
 
2948 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2949 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2950 
    args = markOrderAsDelivered_args()
2951 
    args.orderId = orderId
2952 
    args.deliveryTimestamp = deliveryTimestamp
2953 
    args.receiver = receiver
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_markOrderAsDelivered(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = markOrderAsDelivered_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.ex is not None:
2969 
      raise result.ex
2970 
    return
2971 
 
4454 rajveer 2972 
  def markOrderDoaRequestReceived(self, orderId):
2973 
    """
2974 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2975 
 
2976 
    Parameters:
2977 
     - orderId
2978 
    """
2979 
    self.send_markOrderDoaRequestReceived(orderId)
2980 
    return self.recv_markOrderDoaRequestReceived()
2981 
 
2982 
  def send_markOrderDoaRequestReceived(self, orderId):
2983 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2984 
    args = markOrderDoaRequestReceived_args()
2985 
    args.orderId = orderId
2986 
    args.write(self._oprot)
2987 
    self._oprot.writeMessageEnd()
2988 
    self._oprot.trans.flush()
2989 
 
2990 
  def recv_markOrderDoaRequestReceived(self, ):
2991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2992 
    if mtype == TMessageType.EXCEPTION:
2993 
      x = TApplicationException()
2994 
      x.read(self._iprot)
2995 
      self._iprot.readMessageEnd()
2996 
      raise x
2997 
    result = markOrderDoaRequestReceived_result()
2998 
    result.read(self._iprot)
2999 
    self._iprot.readMessageEnd()
3000 
    if result.success is not None:
3001 
      return result.success
3002 
    if result.ex is not None:
3003 
      raise result.ex
3004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3005 
 
3006 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3007 
    """
3008 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3009 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3010 
 
3011 
    Parameters:
3012 
     - orderId
3013 
     - isAuthorized
3014 
    """
3015 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3016 
    return self.recv_markOrderDoaRequestAuthorized()
3017 
 
3018 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3019 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3020 
    args = markOrderDoaRequestAuthorized_args()
3021 
    args.orderId = orderId
3022 
    args.isAuthorized = isAuthorized
3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3027 
  def recv_markOrderDoaRequestAuthorized(self, ):
3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3034 
    result = markOrderDoaRequestAuthorized_result()
3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    if result.success is not None:
3038 
      return result.success
3039 
    if result.ex is not None:
3040 
      raise result.ex
3041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3042 
 
4488 rajveer 3043 
  def markOrderReturnRequestReceived(self, orderId):
3044 
    """
3045 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3046 
 
3047 
    Parameters:
3048 
     - orderId
3049 
    """
3050 
    self.send_markOrderReturnRequestReceived(orderId)
3051 
    return self.recv_markOrderReturnRequestReceived()
3052 
 
3053 
  def send_markOrderReturnRequestReceived(self, orderId):
3054 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3055 
    args = markOrderReturnRequestReceived_args()
3056 
    args.orderId = orderId
3057 
    args.write(self._oprot)
3058 
    self._oprot.writeMessageEnd()
3059 
    self._oprot.trans.flush()
3060 
 
3061 
  def recv_markOrderReturnRequestReceived(self, ):
3062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3063 
    if mtype == TMessageType.EXCEPTION:
3064 
      x = TApplicationException()
3065 
      x.read(self._iprot)
3066 
      self._iprot.readMessageEnd()
3067 
      raise x
3068 
    result = markOrderReturnRequestReceived_result()
3069 
    result.read(self._iprot)
3070 
    self._iprot.readMessageEnd()
3071 
    if result.success is not None:
3072 
      return result.success
3073 
    if result.ex is not None:
3074 
      raise result.ex
3075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3076 
 
3077 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3078 
    """
3079 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3080 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3081 
 
3082 
    Parameters:
3083 
     - orderId
3084 
     - isAuthorized
3085 
    """
3086 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3087 
    return self.recv_markOrderReturnRequestAuthorized()
3088 
 
3089 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3090 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3091 
    args = markOrderReturnRequestAuthorized_args()
3092 
    args.orderId = orderId
3093 
    args.isAuthorized = isAuthorized
3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3098 
  def recv_markOrderReturnRequestAuthorized(self, ):
3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3105 
    result = markOrderReturnRequestAuthorized_result()
3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3108 
    if result.success is not None:
3109 
      return result.success
3110 
    if result.ex is not None:
3111 
      raise result.ex
3112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3113 
 
4579 rajveer 3114 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3115 
    """
3116 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3117 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3118 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3119 
    For any other status, it returns false.
3120 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3121 
 
2536 chandransh 3122 
    Parameters:
3123 
     - orderId
4579 rajveer 3124 
     - providerId
2536 chandransh 3125 
    """
4579 rajveer 3126 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3127 
    return self.recv_requestPickupNumber()
3128 
 
4579 rajveer 3129 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3130 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3131 
    args = requestPickupNumber_args()
3132 
    args.orderId = orderId
4579 rajveer 3133 
    args.providerId = providerId
2536 chandransh 3134 
    args.write(self._oprot)
3135 
    self._oprot.writeMessageEnd()
3136 
    self._oprot.trans.flush()
3137 
 
3138 
  def recv_requestPickupNumber(self, ):
3139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3140 
    if mtype == TMessageType.EXCEPTION:
3141 
      x = TApplicationException()
3142 
      x.read(self._iprot)
3143 
      self._iprot.readMessageEnd()
3144 
      raise x
3145 
    result = requestPickupNumber_result()
3146 
    result.read(self._iprot)
3147 
    self._iprot.readMessageEnd()
3431 rajveer 3148 
    if result.success is not None:
2536 chandransh 3149 
      return result.success
3431 rajveer 3150 
    if result.ex is not None:
2536 chandransh 3151 
      raise result.ex
3152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3153 
 
4602 rajveer 3154 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3155 
    """
4452 rajveer 3156 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3157 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3158 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3159 
    	3. Returns true
2591 chandransh 3160 
    If the order is in any other status, it returns false.
2536 chandransh 3161 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3162 
 
2536 chandransh 3163 
    Parameters:
3164 
     - orderId
3165 
     - pickupNumber
4602 rajveer 3166 
     - providerId
2536 chandransh 3167 
    """
4602 rajveer 3168 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3169 
    return self.recv_authorizePickup()
3170 
 
4602 rajveer 3171 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3172 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3173 
    args = authorizePickup_args()
3174 
    args.orderId = orderId
3175 
    args.pickupNumber = pickupNumber
4602 rajveer 3176 
    args.providerId = providerId
2536 chandransh 3177 
    args.write(self._oprot)
3178 
    self._oprot.writeMessageEnd()
3179 
    self._oprot.trans.flush()
3180 
 
3181 
  def recv_authorizePickup(self, ):
3182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3183 
    if mtype == TMessageType.EXCEPTION:
3184 
      x = TApplicationException()
3185 
      x.read(self._iprot)
3186 
      self._iprot.readMessageEnd()
3187 
      raise x
3188 
    result = authorizePickup_result()
3189 
    result.read(self._iprot)
3190 
    self._iprot.readMessageEnd()
3431 rajveer 3191 
    if result.success is not None:
2536 chandransh 3192 
      return result.success
3431 rajveer 3193 
    if result.ex is not None:
2536 chandransh 3194 
      raise result.ex
3195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3196 
 
2764 chandransh 3197 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3198 
    """
3199 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3200 
 
2764 chandransh 3201 
    Parameters:
3202 
     - providerId
3203 
     - pickupDetails
3204 
    """
3205 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3206 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3207 
 
3208 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3209 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3210 
    args = markDoasAsPickedUp_args()
3211 
    args.providerId = providerId
3212 
    args.pickupDetails = pickupDetails
3213 
    args.write(self._oprot)
3214 
    self._oprot.writeMessageEnd()
3215 
    self._oprot.trans.flush()
3216 
 
3217 
  def recv_markDoasAsPickedUp(self, ):
3218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3219 
    if mtype == TMessageType.EXCEPTION:
3220 
      x = TApplicationException()
3221 
      x.read(self._iprot)
3222 
      self._iprot.readMessageEnd()
3223 
      raise x
3224 
    result = markDoasAsPickedUp_result()
3225 
    result.read(self._iprot)
3226 
    self._iprot.readMessageEnd()
4910 phani.kuma 3227 
    return
3228 
 
3229 
  def getDoasNotPickedUp(self, providerId):
3230 
    """
3231 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3232 
 
3233 
    Parameters:
3234 
     - providerId
3235 
    """
3236 
    self.send_getDoasNotPickedUp(providerId)
3237 
    return self.recv_getDoasNotPickedUp()
3238 
 
3239 
  def send_getDoasNotPickedUp(self, providerId):
3240 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3241 
    args = getDoasNotPickedUp_args()
3242 
    args.providerId = providerId
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_getDoasNotPickedUp(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = getDoasNotPickedUp_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
3431 rajveer 3257 
    if result.success is not None:
2764 chandransh 3258 
      return result.success
4910 phani.kuma 3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3260 
 
4741 phani.kuma 3261 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3262 
    """
3263 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3264 
 
3265 
    Parameters:
3266 
     - providerId
3267 
     - pickupDetails
3268 
    """
3269 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3270 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3271 
 
3272 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3273 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3274 
    args = markReturnOrdersAsPickedUp_args()
3275 
    args.providerId = providerId
3276 
    args.pickupDetails = pickupDetails
3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_markReturnOrdersAsPickedUp(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = markReturnOrdersAsPickedUp_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
4910 phani.kuma 3291 
    return
3292 
 
3293 
  def getReturnOrdersNotPickedUp(self, providerId):
3294 
    """
3295 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3296 
 
3297 
    Parameters:
3298 
     - providerId
3299 
    """
3300 
    self.send_getReturnOrdersNotPickedUp(providerId)
3301 
    return self.recv_getReturnOrdersNotPickedUp()
3302 
 
3303 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3304 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3305 
    args = getReturnOrdersNotPickedUp_args()
3306 
    args.providerId = providerId
3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_getReturnOrdersNotPickedUp(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = getReturnOrdersNotPickedUp_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
4741 phani.kuma 3321 
    if result.success is not None:
3322 
      return result.success
4910 phani.kuma 3323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3324 
 
4479 rajveer 3325 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3326 
    """
4452 rajveer 3327 
    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 3328 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3329 
    If the order is in any other state, it returns false.
3330 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3331 
 
2591 chandransh 3332 
    Parameters:
3333 
     - orderId
4479 rajveer 3334 
     - receiveCondition
2591 chandransh 3335 
    """
4479 rajveer 3336 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3337 
    return self.recv_receiveReturn()
2536 chandransh 3338 
 
4479 rajveer 3339 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3340 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3341 
    args = receiveReturn_args()
2591 chandransh 3342 
    args.orderId = orderId
4479 rajveer 3343 
    args.receiveCondition = receiveCondition
2591 chandransh 3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
2616 chandransh 3348 
  def recv_receiveReturn(self, ):
2591 chandransh 3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
2616 chandransh 3355 
    result = receiveReturn_result()
2591 chandransh 3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3431 rajveer 3358 
    if result.success is not None:
2591 chandransh 3359 
      return result.success
3431 rajveer 3360 
    if result.ex is not None:
2591 chandransh 3361 
      raise result.ex
2616 chandransh 3362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3363 
 
3364 
  def validateDoa(self, orderId, isValid):
3365 
    """
4452 rajveer 3366 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3367 
    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 3368 
    If the order is in any other state, it returns false.
3369 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3370 
 
2591 chandransh 3371 
    Parameters:
3372 
     - orderId
3373 
     - isValid
3374 
    """
3375 
    self.send_validateDoa(orderId, isValid)
3376 
    return self.recv_validateDoa()
3377 
 
3378 
  def send_validateDoa(self, orderId, isValid):
3379 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3380 
    args = validateDoa_args()
3381 
    args.orderId = orderId
3382 
    args.isValid = isValid
3383 
    args.write(self._oprot)
3384 
    self._oprot.writeMessageEnd()
3385 
    self._oprot.trans.flush()
3386 
 
3387 
  def recv_validateDoa(self, ):
3388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3389 
    if mtype == TMessageType.EXCEPTION:
3390 
      x = TApplicationException()
3391 
      x.read(self._iprot)
3392 
      self._iprot.readMessageEnd()
3393 
      raise x
3394 
    result = validateDoa_result()
3395 
    result.read(self._iprot)
3396 
    self._iprot.readMessageEnd()
3431 rajveer 3397 
    if result.success is not None:
2591 chandransh 3398 
      return result.success
3431 rajveer 3399 
    if result.ex is not None:
2591 chandransh 3400 
      raise result.ex
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3402 
 
4495 rajveer 3403 
  def validateReturnProduct(self, orderId, isUsable):
3404 
    """
3405 
    Parameters:
3406 
     - orderId
3407 
     - isUsable
3408 
    """
3409 
    self.send_validateReturnProduct(orderId, isUsable)
3410 
    return self.recv_validateReturnProduct()
3411 
 
3412 
  def send_validateReturnProduct(self, orderId, isUsable):
3413 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3414 
    args = validateReturnProduct_args()
3415 
    args.orderId = orderId
3416 
    args.isUsable = isUsable
3417 
    args.write(self._oprot)
3418 
    self._oprot.writeMessageEnd()
3419 
    self._oprot.trans.flush()
3420 
 
3421 
  def recv_validateReturnProduct(self, ):
3422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3423 
    if mtype == TMessageType.EXCEPTION:
3424 
      x = TApplicationException()
3425 
      x.read(self._iprot)
3426 
      self._iprot.readMessageEnd()
3427 
      raise x
3428 
    result = validateReturnProduct_result()
3429 
    result.read(self._iprot)
3430 
    self._iprot.readMessageEnd()
3431 
    if result.success is not None:
3432 
      return result.success
3433 
    if result.ex is not None:
3434 
      raise result.ex
3435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3436 
 
2616 chandransh 3437 
  def reshipOrder(self, orderId):
3438 
    """
4484 rajveer 3439 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3440 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3441 
    	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 3442 
 
3443 
    If the order is in DOA_CERT_VALID state, it does the following:
3444 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3445 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3446 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3447 
 
2616 chandransh 3448 
    Returns the id of the newly created order.
3431 rajveer 3449 
 
2616 chandransh 3450 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3451 
 
2616 chandransh 3452 
    Parameters:
3453 
     - orderId
3454 
    """
3455 
    self.send_reshipOrder(orderId)
3456 
    return self.recv_reshipOrder()
2591 chandransh 3457 
 
2616 chandransh 3458 
  def send_reshipOrder(self, orderId):
3459 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3460 
    args = reshipOrder_args()
3461 
    args.orderId = orderId
3462 
    args.write(self._oprot)
3463 
    self._oprot.writeMessageEnd()
3464 
    self._oprot.trans.flush()
3465 
 
3466 
  def recv_reshipOrder(self, ):
3467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3468 
    if mtype == TMessageType.EXCEPTION:
3469 
      x = TApplicationException()
3470 
      x.read(self._iprot)
3471 
      self._iprot.readMessageEnd()
3472 
      raise x
3473 
    result = reshipOrder_result()
3474 
    result.read(self._iprot)
3475 
    self._iprot.readMessageEnd()
3431 rajveer 3476 
    if result.success is not None:
2616 chandransh 3477 
      return result.success
3431 rajveer 3478 
    if result.ex is not None:
2616 chandransh 3479 
      raise result.ex
3480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3481 
 
3226 chandransh 3482 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3483 
    """
4484 rajveer 3484 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3485 
    	1. Creates a refund request for batch processing.
3486 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3487 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3488 
 
2616 chandransh 3489 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3490 
    	1. Creates a refund request for batch processing.
3226 chandransh 3491 
    	2. Cancels the reservation of the item in the warehouse.
3492 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3493 
 
3226 chandransh 3494 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3495 
    	1. Cancels the reservation of the item in the warehouse.
3496 
    	2. Marks the current order as CANCELED.
3497 
 
3498 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3499 
 
2616 chandransh 3500 
    Returns True if it is successful, False otherwise.
3431 rajveer 3501 
 
2616 chandransh 3502 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3503 
 
2616 chandransh 3504 
    Parameters:
3505 
     - orderId
3226 chandransh 3506 
     - refundedBy
3507 
     - reason
2616 chandransh 3508 
    """
3226 chandransh 3509 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3510 
    return self.recv_refundOrder()
3511 
 
3226 chandransh 3512 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3513 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3514 
    args = refundOrder_args()
3515 
    args.orderId = orderId
3226 chandransh 3516 
    args.refundedBy = refundedBy
3517 
    args.reason = reason
2616 chandransh 3518 
    args.write(self._oprot)
3519 
    self._oprot.writeMessageEnd()
3520 
    self._oprot.trans.flush()
3521 
 
3522 
  def recv_refundOrder(self, ):
3523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3524 
    if mtype == TMessageType.EXCEPTION:
3525 
      x = TApplicationException()
3526 
      x.read(self._iprot)
3527 
      self._iprot.readMessageEnd()
3528 
      raise x
3529 
    result = refundOrder_result()
3530 
    result.read(self._iprot)
3531 
    self._iprot.readMessageEnd()
3431 rajveer 3532 
    if result.success is not None:
2616 chandransh 3533 
      return result.success
3431 rajveer 3534 
    if result.ex is not None:
2616 chandransh 3535 
      raise result.ex
3536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3537 
 
2690 chandransh 3538 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3539 
    """
3540 
    Get all return orders created between the from and to dates for the given warehouse.
3541 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3542 
 
2690 chandransh 3543 
    Parameters:
3544 
     - warehouseId
3545 
     - fromDate
3546 
     - toDate
3547 
    """
3548 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3549 
    return self.recv_getReturnOrders()
2616 chandransh 3550 
 
2690 chandransh 3551 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3552 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3553 
    args = getReturnOrders_args()
3554 
    args.warehouseId = warehouseId
3555 
    args.fromDate = fromDate
3556 
    args.toDate = toDate
3557 
    args.write(self._oprot)
3558 
    self._oprot.writeMessageEnd()
3559 
    self._oprot.trans.flush()
3560 
 
3561 
  def recv_getReturnOrders(self, ):
3562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3563 
    if mtype == TMessageType.EXCEPTION:
3564 
      x = TApplicationException()
3565 
      x.read(self._iprot)
3566 
      self._iprot.readMessageEnd()
3567 
      raise x
3568 
    result = getReturnOrders_result()
3569 
    result.read(self._iprot)
3570 
    self._iprot.readMessageEnd()
3431 rajveer 3571 
    if result.success is not None:
2690 chandransh 3572 
      return result.success
3573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3574 
 
2700 chandransh 3575 
  def getReturnOrder(self, id):
3576 
    """
3577 
    Returns the ReturnOrder corresponding to the given id.
3578 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3579 
 
2700 chandransh 3580 
    Parameters:
3581 
     - id
3582 
    """
3583 
    self.send_getReturnOrder(id)
3584 
    return self.recv_getReturnOrder()
3585 
 
3586 
  def send_getReturnOrder(self, id):
3587 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3588 
    args = getReturnOrder_args()
3589 
    args.id = id
3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
3594 
  def recv_getReturnOrder(self, ):
3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
3601 
    result = getReturnOrder_result()
3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
3431 rajveer 3604 
    if result.success is not None:
2700 chandransh 3605 
      return result.success
3431 rajveer 3606 
    if result.ex is not None:
2700 chandransh 3607 
      raise result.ex
3608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3609 
 
2690 chandransh 3610 
  def processReturn(self, returnOrderId):
3611 
    """
3612 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3613 
 
2690 chandransh 3614 
    Parameters:
3615 
     - returnOrderId
3616 
    """
3617 
    self.send_processReturn(returnOrderId)
3618 
    self.recv_processReturn()
3619 
 
3620 
  def send_processReturn(self, returnOrderId):
3621 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3622 
    args = processReturn_args()
3623 
    args.returnOrderId = returnOrderId
3624 
    args.write(self._oprot)
3625 
    self._oprot.writeMessageEnd()
3626 
    self._oprot.trans.flush()
3627 
 
3628 
  def recv_processReturn(self, ):
3629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3630 
    if mtype == TMessageType.EXCEPTION:
3631 
      x = TApplicationException()
3632 
      x.read(self._iprot)
3633 
      self._iprot.readMessageEnd()
3634 
      raise x
3635 
    result = processReturn_result()
3636 
    result.read(self._iprot)
3637 
    self._iprot.readMessageEnd()
3431 rajveer 3638 
    if result.ex is not None:
2690 chandransh 3639 
      raise result.ex
3640 
    return
3641 
 
3451 chandransh 3642 
  def updateWeight(self, orderId, weight):
3643 
    """
3644 
    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 3645 
 
3451 chandransh 3646 
    Parameters:
3647 
     - orderId
3648 
     - weight
3649 
    """
3650 
    self.send_updateWeight(orderId, weight)
3651 
    return self.recv_updateWeight()
3652 
 
3653 
  def send_updateWeight(self, orderId, weight):
3654 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3655 
    args = updateWeight_args()
3656 
    args.orderId = orderId
3657 
    args.weight = weight
3658 
    args.write(self._oprot)
3659 
    self._oprot.writeMessageEnd()
3660 
    self._oprot.trans.flush()
3661 
 
3662 
  def recv_updateWeight(self, ):
3663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3664 
    if mtype == TMessageType.EXCEPTION:
3665 
      x = TApplicationException()
3666 
      x.read(self._iprot)
3667 
      self._iprot.readMessageEnd()
3668 
      raise x
3669 
    result = updateWeight_result()
3670 
    result.read(self._iprot)
3671 
    self._iprot.readMessageEnd()
3672 
    if result.success is not None:
3673 
      return result.success
3674 
    if result.ex is not None:
3675 
      raise result.ex
3676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3677 
 
3469 chandransh 3678 
  def changeItem(self, orderId, itemId):
3679 
    """
3680 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3681 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3682 
 
3469 chandransh 3683 
    Parameters:
3684 
     - orderId
3685 
     - itemId
3686 
    """
3687 
    self.send_changeItem(orderId, itemId)
3688 
    return self.recv_changeItem()
3689 
 
3690 
  def send_changeItem(self, orderId, itemId):
3691 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3692 
    args = changeItem_args()
3693 
    args.orderId = orderId
3694 
    args.itemId = itemId
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_changeItem(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = changeItem_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3709 
    if result.success is not None:
3710 
      return result.success
3711 
    if result.ex is not None:
3712 
      raise result.ex
3713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3714 
 
3715 
  def shiftToWarehouse(self, orderId, warehouseId):
3716 
    """
3717 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3718 
 
3719 
    Parameters:
3720 
     - orderId
3721 
     - warehouseId
3722 
    """
3723 
    self.send_shiftToWarehouse(orderId, warehouseId)
3724 
    return self.recv_shiftToWarehouse()
3725 
 
3726 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3727 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3728 
    args = shiftToWarehouse_args()
3729 
    args.orderId = orderId
3730 
    args.warehouseId = warehouseId
3731 
    args.write(self._oprot)
3732 
    self._oprot.writeMessageEnd()
3733 
    self._oprot.trans.flush()
3734 
 
3735 
  def recv_shiftToWarehouse(self, ):
3736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3737 
    if mtype == TMessageType.EXCEPTION:
3738 
      x = TApplicationException()
3739 
      x.read(self._iprot)
3740 
      self._iprot.readMessageEnd()
3741 
      raise x
3742 
    result = shiftToWarehouse_result()
3743 
    result.read(self._iprot)
3744 
    self._iprot.readMessageEnd()
3745 
    if result.success is not None:
3746 
      return result.success
3747 
    if result.ex is not None:
3748 
      raise result.ex
3749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3750 
 
4647 rajveer 3751 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3752 
    """
3753 
    Adds the given delay reason to the given order.
3986 chandransh 3754 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3755 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3756 
 
3553 chandransh 3757 
    Parameters:
3758 
     - orderId
3759 
     - delayReason
3986 chandransh 3760 
     - furtherDelay
4647 rajveer 3761 
     - delayReasonText
3553 chandransh 3762 
    """
4647 rajveer 3763 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3764 
    return self.recv_addDelayReason()
3765 
 
4647 rajveer 3766 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3767 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3768 
    args = addDelayReason_args()
3769 
    args.orderId = orderId
3770 
    args.delayReason = delayReason
3986 chandransh 3771 
    args.furtherDelay = furtherDelay
4647 rajveer 3772 
    args.delayReasonText = delayReasonText
3553 chandransh 3773 
    args.write(self._oprot)
3774 
    self._oprot.writeMessageEnd()
3775 
    self._oprot.trans.flush()
3776 
 
3777 
  def recv_addDelayReason(self, ):
3778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3779 
    if mtype == TMessageType.EXCEPTION:
3780 
      x = TApplicationException()
3781 
      x.read(self._iprot)
3782 
      self._iprot.readMessageEnd()
3783 
      raise x
3784 
    result = addDelayReason_result()
3785 
    result.read(self._iprot)
3786 
    self._iprot.readMessageEnd()
3787 
    if result.success is not None:
3788 
      return result.success
3789 
    if result.ex is not None:
3790 
      raise result.ex
3791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3792 
 
3956 chandransh 3793 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3794 
    """
3795 
    Marks the COD orders with given AWB nos. as having been processed.
3796 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3797 
 
3956 chandransh 3798 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3799 
    1. There is no order corresponding to an AWB number.
3800 
    2. The captured amount for a payment exceeds the total payment.
3801 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3802 
 
3803 
    Parameters:
3804 
     - collectedAmountMap
3805 
     - xferBy
3806 
     - xferTxnId
3807 
     - xferDate
3808 
    """
3809 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3810 
    return self.recv_reconcileCodCollection()
3811 
 
3812 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3813 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3814 
    args = reconcileCodCollection_args()
3815 
    args.collectedAmountMap = collectedAmountMap
3816 
    args.xferBy = xferBy
3817 
    args.xferTxnId = xferTxnId
3818 
    args.xferDate = xferDate
3819 
    args.write(self._oprot)
3820 
    self._oprot.writeMessageEnd()
3821 
    self._oprot.trans.flush()
3822 
 
3823 
  def recv_reconcileCodCollection(self, ):
3824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3825 
    if mtype == TMessageType.EXCEPTION:
3826 
      x = TApplicationException()
3827 
      x.read(self._iprot)
3828 
      self._iprot.readMessageEnd()
3829 
      raise x
3830 
    result = reconcileCodCollection_result()
3831 
    result.read(self._iprot)
3832 
    self._iprot.readMessageEnd()
3833 
    if result.success is not None:
3834 
      return result.success
3835 
    if result.ex is not None:
3836 
      raise result.ex
3837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3838 
 
4008 mandeep.dh 3839 
  def getTransactionsRequiringExtraProcessing(self, category):
3840 
    """
4065 mandeep.dh 3841 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3842 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3843 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3844 
 
4008 mandeep.dh 3845 
    Parameters:
3846 
     - category
3847 
    """
3848 
    self.send_getTransactionsRequiringExtraProcessing(category)
3849 
    return self.recv_getTransactionsRequiringExtraProcessing()
3850 
 
3851 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3852 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3853 
    args = getTransactionsRequiringExtraProcessing_args()
3854 
    args.category = category
3855 
    args.write(self._oprot)
3856 
    self._oprot.writeMessageEnd()
3857 
    self._oprot.trans.flush()
3858 
 
3859 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3861 
    if mtype == TMessageType.EXCEPTION:
3862 
      x = TApplicationException()
3863 
      x.read(self._iprot)
3864 
      self._iprot.readMessageEnd()
3865 
      raise x
3866 
    result = getTransactionsRequiringExtraProcessing_result()
3867 
    result.read(self._iprot)
3868 
    self._iprot.readMessageEnd()
3869 
    if result.success is not None:
3870 
      return result.success
3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3872 
 
3873 
  def markTransactionAsProcessed(self, transactionId, category):
3874 
    """
3875 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3876 
    It essentially deletes the transaction id record for a particular
3877 
    processing type category (if present) from DB.
3878 
    This is currently used by CRM application.
4008 mandeep.dh 3879 
 
3880 
    Parameters:
3881 
     - transactionId
3882 
     - category
3883 
    """
3884 
    self.send_markTransactionAsProcessed(transactionId, category)
3885 
    self.recv_markTransactionAsProcessed()
3886 
 
3887 
  def send_markTransactionAsProcessed(self, transactionId, category):
3888 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3889 
    args = markTransactionAsProcessed_args()
3890 
    args.transactionId = transactionId
3891 
    args.category = category
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_markTransactionAsProcessed(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = markTransactionAsProcessed_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3906 
    return
3907 
 
4018 chandransh 3908 
  def getItemWiseRiskyOrdersCount(self, ):
3909 
    """
3910 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3911 
    is defined as one whose shipping date is about to expire.
3912 
    """
3913 
    self.send_getItemWiseRiskyOrdersCount()
3914 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3915 
 
4018 chandransh 3916 
  def send_getItemWiseRiskyOrdersCount(self, ):
3917 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3918 
    args = getItemWiseRiskyOrdersCount_args()
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = getItemWiseRiskyOrdersCount_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3933 
    if result.success is not None:
3934 
      return result.success
3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3936 
 
4295 varun.gupt 3937 
  def getOrdersForItemIds(self, itemIds):
3938 
    """
3939 
    Returns a list of all orders which have items with given id
3940 
 
3941 
    Parameters:
3942 
     - itemIds
3943 
    """
3944 
    self.send_getOrdersForItemIds(itemIds)
3945 
    return self.recv_getOrdersForItemIds()
3946 
 
3947 
  def send_getOrdersForItemIds(self, itemIds):
3948 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3949 
    args = getOrdersForItemIds_args()
3950 
    args.itemIds = itemIds
3951 
    args.write(self._oprot)
3952 
    self._oprot.writeMessageEnd()
3953 
    self._oprot.trans.flush()
3954 
 
3955 
  def recv_getOrdersForItemIds(self, ):
3956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3957 
    if mtype == TMessageType.EXCEPTION:
3958 
      x = TApplicationException()
3959 
      x.read(self._iprot)
3960 
      self._iprot.readMessageEnd()
3961 
      raise x
3962 
    result = getOrdersForItemIds_result()
3963 
    result.read(self._iprot)
3964 
    self._iprot.readMessageEnd()
3965 
    if result.success is not None:
3966 
      return result.success
3967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3968 
 
4247 rajveer 3969 
  def markOrderCancellationRequestReceived(self, orderId):
3970 
    """
3971 
    Mark order as cancellation request received. If customer sends request of cancellation of
3972 
    a particular order, this method will be called. It will just change status of the order
3973 
    depending on its current status. It also records the previous status, so that we can move
3974 
    back to that status if cancellation request is denied.
4018 chandransh 3975 
 
4247 rajveer 3976 
    Parameters:
3977 
     - orderId
3978 
    """
3979 
    self.send_markOrderCancellationRequestReceived(orderId)
3980 
    self.recv_markOrderCancellationRequestReceived()
3981 
 
3982 
  def send_markOrderCancellationRequestReceived(self, orderId):
3983 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3984 
    args = markOrderCancellationRequestReceived_args()
3985 
    args.orderId = orderId
3986 
    args.write(self._oprot)
3987 
    self._oprot.writeMessageEnd()
3988 
    self._oprot.trans.flush()
3989 
 
3990 
  def recv_markOrderCancellationRequestReceived(self, ):
3991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3992 
    if mtype == TMessageType.EXCEPTION:
3993 
      x = TApplicationException()
3994 
      x.read(self._iprot)
3995 
      self._iprot.readMessageEnd()
3996 
      raise x
3997 
    result = markOrderCancellationRequestReceived_result()
3998 
    result.read(self._iprot)
3999 
    self._iprot.readMessageEnd()
4000 
    if result.ex is not None:
4001 
      raise result.ex
4002 
    return
4003 
 
4004 
  def markOrderCancellationRequestConfirmed(self, orderId):
4005 
    """
4006 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4007 
    cancellation request confirmed. After this OM will be able to cancel the order.
4008 
 
4009 
    Parameters:
4010 
     - orderId
4011 
    """
4012 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4013 
    self.recv_markOrderCancellationRequestConfirmed()
4014 
 
4015 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4016 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4017 
    args = markOrderCancellationRequestConfirmed_args()
4018 
    args.orderId = orderId
4019 
    args.write(self._oprot)
4020 
    self._oprot.writeMessageEnd()
4021 
    self._oprot.trans.flush()
4022 
 
4023 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4025 
    if mtype == TMessageType.EXCEPTION:
4026 
      x = TApplicationException()
4027 
      x.read(self._iprot)
4028 
      self._iprot.readMessageEnd()
4029 
      raise x
4030 
    result = markOrderCancellationRequestConfirmed_result()
4031 
    result.read(self._iprot)
4032 
    self._iprot.readMessageEnd()
4033 
    if result.ex is not None:
4034 
      raise result.ex
4035 
    return
4036 
 
4037 
  def markOrderCancellationRequestDenied(self, orderId):
4038 
    """
4039 
    If we decide to not to cancel order, we will move the order ro previous status.
4040 
 
4041 
    Parameters:
4042 
     - orderId
4043 
    """
4044 
    self.send_markOrderCancellationRequestDenied(orderId)
4045 
    self.recv_markOrderCancellationRequestDenied()
4046 
 
4047 
  def send_markOrderCancellationRequestDenied(self, orderId):
4048 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4049 
    args = markOrderCancellationRequestDenied_args()
4050 
    args.orderId = orderId
4051 
    args.write(self._oprot)
4052 
    self._oprot.writeMessageEnd()
4053 
    self._oprot.trans.flush()
4054 
 
4055 
  def recv_markOrderCancellationRequestDenied(self, ):
4056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4057 
    if mtype == TMessageType.EXCEPTION:
4058 
      x = TApplicationException()
4059 
      x.read(self._iprot)
4060 
      self._iprot.readMessageEnd()
4061 
      raise x
4062 
    result = markOrderCancellationRequestDenied_result()
4063 
    result.read(self._iprot)
4064 
    self._iprot.readMessageEnd()
4065 
    if result.ex is not None:
4066 
      raise result.ex
4067 
    return
4068 
 
4258 rajveer 4069 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4070 
    """
4258 rajveer 4071 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4072 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4073 
 
4074 
    Parameters:
4258 rajveer 4075 
     - transactionId
4247 rajveer 4076 
    """
4258 rajveer 4077 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4078 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4079 
 
4258 rajveer 4080 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4081 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4082 
    args = markTransactionAsPaymentFlagRemoved_args()
4083 
    args.transactionId = transactionId
4247 rajveer 4084 
    args.write(self._oprot)
4085 
    self._oprot.writeMessageEnd()
4086 
    self._oprot.trans.flush()
4087 
 
4258 rajveer 4088 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4090 
    if mtype == TMessageType.EXCEPTION:
4091 
      x = TApplicationException()
4092 
      x.read(self._iprot)
4093 
      self._iprot.readMessageEnd()
4094 
      raise x
4258 rajveer 4095 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4096 
    result.read(self._iprot)
4097 
    self._iprot.readMessageEnd()
4098 
    if result.ex is not None:
4099 
      raise result.ex
4100 
    return
4101 
 
4259 anupam.sin 4102 
  def refundTransaction(self, transactionId, refundedBy, reason):
4103 
    """
4104 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4105 
    need to be cancelled
4247 rajveer 4106 
 
4259 anupam.sin 4107 
    Parameters:
4108 
     - transactionId
4109 
     - refundedBy
4110 
     - reason
4111 
    """
4112 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4113 
    self.recv_refundTransaction()
4114 
 
4115 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4116 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4117 
    args = refundTransaction_args()
4118 
    args.transactionId = transactionId
4119 
    args.refundedBy = refundedBy
4120 
    args.reason = reason
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_refundTransaction(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = refundTransaction_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.ex is not None:
4136 
      raise result.ex
4137 
    return
4138 
 
4324 mandeep.dh 4139 
  def updateShipmentAddress(self, orderId, addressId):
4140 
    """
4141 
    Updates shipment address of an order. Delivery and shipping date estimates
4142 
    etc. are also updated here.
4143 
 
4144 
    Throws TransactionServiceException in case address change is not
4145 
    possible due to certain reasons such as new pincode in address is
4146 
    not serviceable etc.
4147 
 
4148 
    Parameters:
4149 
     - orderId
4150 
     - addressId
4151 
    """
4152 
    self.send_updateShipmentAddress(orderId, addressId)
4153 
    self.recv_updateShipmentAddress()
4154 
 
4155 
  def send_updateShipmentAddress(self, orderId, addressId):
4156 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4157 
    args = updateShipmentAddress_args()
4158 
    args.orderId = orderId
4159 
    args.addressId = addressId
4160 
    args.write(self._oprot)
4161 
    self._oprot.writeMessageEnd()
4162 
    self._oprot.trans.flush()
4163 
 
4164 
  def recv_updateShipmentAddress(self, ):
4165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4166 
    if mtype == TMessageType.EXCEPTION:
4167 
      x = TApplicationException()
4168 
      x.read(self._iprot)
4169 
      self._iprot.readMessageEnd()
4170 
      raise x
4171 
    result = updateShipmentAddress_result()
4172 
    result.read(self._iprot)
4173 
    self._iprot.readMessageEnd()
4174 
    if result.ex is not None:
4175 
      raise result.ex
4176 
    return
4177 
 
4285 rajveer 4178 
  def acceptOrdersForItemId(self, itemId, inventory):
4179 
    """
4180 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4181 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4182 
 
4285 rajveer 4183 
    Parameters:
4184 
     - itemId
4185 
     - inventory
4186 
    """
4187 
    self.send_acceptOrdersForItemId(itemId, inventory)
4188 
    return self.recv_acceptOrdersForItemId()
4189 
 
4190 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4191 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4192 
    args = acceptOrdersForItemId_args()
4193 
    args.itemId = itemId
4194 
    args.inventory = inventory
4195 
    args.write(self._oprot)
4196 
    self._oprot.writeMessageEnd()
4197 
    self._oprot.trans.flush()
4198 
 
4199 
  def recv_acceptOrdersForItemId(self, ):
4200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4201 
    if mtype == TMessageType.EXCEPTION:
4202 
      x = TApplicationException()
4203 
      x.read(self._iprot)
4204 
      self._iprot.readMessageEnd()
4205 
      raise x
4206 
    result = acceptOrdersForItemId_result()
4207 
    result.read(self._iprot)
4208 
    self._iprot.readMessageEnd()
4209 
    if result.success is not None:
4210 
      return result.success
4211 
    if result.ex is not None:
4212 
      raise result.ex
4213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4214 
 
4369 rajveer 4215 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4216 
    """
4217 
    Parameters:
4218 
     - vendorId
4219 
     - itemId
4220 
     - quantity
4221 
     - estimate
4369 rajveer 4222 
     - isReminder
4303 rajveer 4223 
    """
4369 rajveer 4224 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4225 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4226 
 
4369 rajveer 4227 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4228 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4229 
    args = markOrdersAsPORaised_args()
4230 
    args.vendorId = vendorId
4231 
    args.itemId = itemId
4232 
    args.quantity = quantity
4233 
    args.estimate = estimate
4369 rajveer 4234 
    args.isReminder = isReminder
4303 rajveer 4235 
    args.write(self._oprot)
4236 
    self._oprot.writeMessageEnd()
4237 
    self._oprot.trans.flush()
4238 
 
4239 
  def recv_markOrdersAsPORaised(self, ):
4240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4241 
    if mtype == TMessageType.EXCEPTION:
4242 
      x = TApplicationException()
4243 
      x.read(self._iprot)
4244 
      self._iprot.readMessageEnd()
4245 
      raise x
4246 
    result = markOrdersAsPORaised_result()
4247 
    result.read(self._iprot)
4248 
    self._iprot.readMessageEnd()
4249 
    if result.ex is not None:
4250 
      raise result.ex
4251 
    return
4252 
 
4369 rajveer 4253 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4254 
    """
4255 
    Parameters:
4256 
     - vendorId
4257 
     - itemId
4258 
     - quantity
4259 
     - estimate
4369 rajveer 4260 
     - isReminder
4303 rajveer 4261 
    """
4369 rajveer 4262 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4263 
    self.recv_markOrdersAsReversalInitiated()
4264 
 
4369 rajveer 4265 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4266 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4267 
    args = markOrdersAsReversalInitiated_args()
4268 
    args.vendorId = vendorId
4269 
    args.itemId = itemId
4270 
    args.quantity = quantity
4271 
    args.estimate = estimate
4369 rajveer 4272 
    args.isReminder = isReminder
4303 rajveer 4273 
    args.write(self._oprot)
4274 
    self._oprot.writeMessageEnd()
4275 
    self._oprot.trans.flush()
4276 
 
4277 
  def recv_markOrdersAsReversalInitiated(self, ):
4278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4279 
    if mtype == TMessageType.EXCEPTION:
4280 
      x = TApplicationException()
4281 
      x.read(self._iprot)
4282 
      self._iprot.readMessageEnd()
4283 
      raise x
4284 
    result = markOrdersAsReversalInitiated_result()
4285 
    result.read(self._iprot)
4286 
    self._iprot.readMessageEnd()
4287 
    if result.ex is not None:
4288 
      raise result.ex
4289 
    return
4290 
 
4369 rajveer 4291 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4292 
    """
4293 
    Parameters:
4294 
     - vendorId
4295 
     - itemId
4296 
     - quantity
4297 
     - estimate
4369 rajveer 4298 
     - isReminder
4303 rajveer 4299 
    """
4369 rajveer 4300 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4301 
    self.recv_markOrdersAsNotAvailabke()
4302 
 
4369 rajveer 4303 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4304 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4305 
    args = markOrdersAsNotAvailabke_args()
4306 
    args.vendorId = vendorId
4307 
    args.itemId = itemId
4308 
    args.quantity = quantity
4309 
    args.estimate = estimate
4369 rajveer 4310 
    args.isReminder = isReminder
4303 rajveer 4311 
    args.write(self._oprot)
4312 
    self._oprot.writeMessageEnd()
4313 
    self._oprot.trans.flush()
4314 
 
4315 
  def recv_markOrdersAsNotAvailabke(self, ):
4316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4317 
    if mtype == TMessageType.EXCEPTION:
4318 
      x = TApplicationException()
4319 
      x.read(self._iprot)
4320 
      self._iprot.readMessageEnd()
4321 
      raise x
4322 
    result = markOrdersAsNotAvailabke_result()
4323 
    result.read(self._iprot)
4324 
    self._iprot.readMessageEnd()
4325 
    if result.ex is not None:
4326 
      raise result.ex
4327 
    return
4328 
 
4369 rajveer 4329 
  def markOrdersAsTimeout(self, vendorId):
4330 
    """
4331 
    Parameters:
4332 
     - vendorId
4333 
    """
4334 
    self.send_markOrdersAsTimeout(vendorId)
4335 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4336 
 
4369 rajveer 4337 
  def send_markOrdersAsTimeout(self, vendorId):
4338 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4339 
    args = markOrdersAsTimeout_args()
4340 
    args.vendorId = vendorId
4341 
    args.write(self._oprot)
4342 
    self._oprot.writeMessageEnd()
4343 
    self._oprot.trans.flush()
4344 
 
4345 
  def recv_markOrdersAsTimeout(self, ):
4346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4347 
    if mtype == TMessageType.EXCEPTION:
4348 
      x = TApplicationException()
4349 
      x.read(self._iprot)
4350 
      self._iprot.readMessageEnd()
4351 
      raise x
4352 
    result = markOrdersAsTimeout_result()
4353 
    result.read(self._iprot)
4354 
    self._iprot.readMessageEnd()
4355 
    if result.success is not None:
4356 
      return result.success
4357 
    if result.ex is not None:
4358 
      raise result.ex
4359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4360 
 
4662 rajveer 4361 
  def markOrderAsLostInTransit(self, orderId):
4362 
    """
4363 
    Mark order as LOST_IN_TRANSIT
4364 
 
4365 
    Parameters:
4366 
     - orderId
4367 
    """
4368 
    self.send_markOrderAsLostInTransit(orderId)
4369 
    return self.recv_markOrderAsLostInTransit()
4370 
 
4371 
  def send_markOrderAsLostInTransit(self, orderId):
4372 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4373 
    args = markOrderAsLostInTransit_args()
4374 
    args.orderId = orderId
4375 
    args.write(self._oprot)
4376 
    self._oprot.writeMessageEnd()
4377 
    self._oprot.trans.flush()
4378 
 
4379 
  def recv_markOrderAsLostInTransit(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 = markOrderAsLostInTransit_result()
4387 
    result.read(self._iprot)
4388 
    self._iprot.readMessageEnd()
4389 
    if result.success is not None:
4390 
      return result.success
4391 
    if result.ex is not None:
4392 
      raise result.ex
4393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4394 
 
4386 anupam.sin 4395 
  def getOrderForAwb(self, awb):
4396 
    """
4397 
    Returns the order corresponding to an AWB number
4369 rajveer 4398 
 
4386 anupam.sin 4399 
    Parameters:
4400 
     - awb
4401 
    """
4402 
    self.send_getOrderForAwb(awb)
4403 
    return self.recv_getOrderForAwb()
4404 
 
4405 
  def send_getOrderForAwb(self, awb):
4406 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4407 
    args = getOrderForAwb_args()
4408 
    args.awb = awb
4409 
    args.write(self._oprot)
4410 
    self._oprot.writeMessageEnd()
4411 
    self._oprot.trans.flush()
4412 
 
4413 
  def recv_getOrderForAwb(self, ):
4414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4415 
    if mtype == TMessageType.EXCEPTION:
4416 
      x = TApplicationException()
4417 
      x.read(self._iprot)
4418 
      self._iprot.readMessageEnd()
4419 
      raise x
4420 
    result = getOrderForAwb_result()
4421 
    result.read(self._iprot)
4422 
    self._iprot.readMessageEnd()
4423 
    if result.success is not None:
4424 
      return result.success
4425 
    if result.ex is not None:
4426 
      raise result.ex
4427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4428 
 
4910 phani.kuma 4429 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4430 
    """
4910 phani.kuma 4431 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4432 
 
4506 phani.kuma 4433 
    Parameters:
4434 
     - logistics_provider_id
4910 phani.kuma 4435 
     - order_status_list
4506 phani.kuma 4436 
    """
4910 phani.kuma 4437 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4438 
    return self.recv_getOrdersForProviderForStatus()
4439 
 
4910 phani.kuma 4440 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4441 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4442 
    args = getOrdersForProviderForStatus_args()
4443 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4444 
    args.order_status_list = order_status_list
4506 phani.kuma 4445 
    args.write(self._oprot)
4446 
    self._oprot.writeMessageEnd()
4447 
    self._oprot.trans.flush()
4448 
 
4449 
  def recv_getOrdersForProviderForStatus(self, ):
4450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4451 
    if mtype == TMessageType.EXCEPTION:
4452 
      x = TApplicationException()
4453 
      x.read(self._iprot)
4454 
      self._iprot.readMessageEnd()
4455 
      raise x
4456 
    result = getOrdersForProviderForStatus_result()
4457 
    result.read(self._iprot)
4458 
    self._iprot.readMessageEnd()
4459 
    if result.success is not None:
4460 
      return result.success
4461 
    if result.ex is not None:
4462 
      raise result.ex
4463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4464 
 
4600 varun.gupt 4465 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4466 
    """
4467 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4468 
 
4600 varun.gupt 4469 
    Parameters:
4470 
     - vendorId
4471 
     - billingDateFrom
4472 
     - billingDateTo
4473 
    """
4474 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4475 
    return self.recv_getBilledOrdersForVendor()
4476 
 
4477 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4478 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4479 
    args = getBilledOrdersForVendor_args()
4480 
    args.vendorId = vendorId
4481 
    args.billingDateFrom = billingDateFrom
4482 
    args.billingDateTo = billingDateTo
4483 
    args.write(self._oprot)
4484 
    self._oprot.writeMessageEnd()
4485 
    self._oprot.trans.flush()
4486 
 
4487 
  def recv_getBilledOrdersForVendor(self, ):
4488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4489 
    if mtype == TMessageType.EXCEPTION:
4490 
      x = TApplicationException()
4491 
      x.read(self._iprot)
4492 
      self._iprot.readMessageEnd()
4493 
      raise x
4494 
    result = getBilledOrdersForVendor_result()
4495 
    result.read(self._iprot)
4496 
    self._iprot.readMessageEnd()
4497 
    if result.success is not None:
4498 
      return result.success
4499 
    if result.ex is not None:
4500 
      raise result.ex
4501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4502 
 
4607 rajveer 4503 
  def getSlippedSippingDateOrders(self, ):
4504 
    self.send_getSlippedSippingDateOrders()
4505 
    return self.recv_getSlippedSippingDateOrders()
4506 
 
4507 
  def send_getSlippedSippingDateOrders(self, ):
4508 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4509 
    args = getSlippedSippingDateOrders_args()
4510 
    args.write(self._oprot)
4511 
    self._oprot.writeMessageEnd()
4512 
    self._oprot.trans.flush()
4513 
 
4514 
  def recv_getSlippedSippingDateOrders(self, ):
4515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4516 
    if mtype == TMessageType.EXCEPTION:
4517 
      x = TApplicationException()
4518 
      x.read(self._iprot)
4519 
      self._iprot.readMessageEnd()
4520 
      raise x
4521 
    result = getSlippedSippingDateOrders_result()
4522 
    result.read(self._iprot)
4523 
    self._iprot.readMessageEnd()
4524 
    if result.success is not None:
4525 
      return result.success
4526 
    if result.ex is not None:
4527 
      raise result.ex
4528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4529 
 
4709 rajveer 4530 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4531 
    """
4532 
    Parameters:
4533 
     - cancelDateFrom
4534 
     - cancelDateTo
4535 
    """
4536 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4537 
    return self.recv_getCancelledOrders()
4538 
 
4539 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4540 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4541 
    args = getCancelledOrders_args()
4542 
    args.cancelDateFrom = cancelDateFrom
4543 
    args.cancelDateTo = cancelDateTo
4544 
    args.write(self._oprot)
4545 
    self._oprot.writeMessageEnd()
4546 
    self._oprot.trans.flush()
4547 
 
4548 
  def recv_getCancelledOrders(self, ):
4549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4550 
    if mtype == TMessageType.EXCEPTION:
4551 
      x = TApplicationException()
4552 
      x.read(self._iprot)
4553 
      self._iprot.readMessageEnd()
4554 
      raise x
4555 
    result = getCancelledOrders_result()
4556 
    result.read(self._iprot)
4557 
    self._iprot.readMessageEnd()
4558 
    if result.success is not None:
4559 
      return result.success
4560 
    if result.ex is not None:
4561 
      raise result.ex
4562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4563 
 
4600 varun.gupt 4564 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4565 
    """
4566 
    Parameters:
4567 
     - mapAWBAndAmount
4568 
    """
4569 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4570 
    self.recv_saveBluedartSettlements()
4571 
 
4572 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4573 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4574 
    args = saveBluedartSettlements_args()
4575 
    args.mapAWBAndAmount = mapAWBAndAmount
4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_saveBluedartSettlements(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = saveBluedartSettlements_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.ex is not None:
4591 
      raise result.ex
4592 
    return
4593 
 
4905 varun.gupt 4594 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4595 
    """
4596 
    Parameters:
4597 
     - settlementDate
4598 
     - paymentGatewayId
4905 varun.gupt 4599 
     - referenceId
4600 varun.gupt 4600 
     - serviceTax
4601 
     - otherCharges
4602 
     - netCollection
4603 
    """
4905 varun.gupt 4604 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4605 
    self.recv_savePaymentSettlements()
4606 
 
4905 varun.gupt 4607 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4608 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4609 
    args = savePaymentSettlements_args()
4610 
    args.settlementDate = settlementDate
4611 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4612 
    args.referenceId = referenceId
4600 varun.gupt 4613 
    args.serviceTax = serviceTax
4614 
    args.otherCharges = otherCharges
4615 
    args.netCollection = netCollection
4616 
    args.write(self._oprot)
4617 
    self._oprot.writeMessageEnd()
4618 
    self._oprot.trans.flush()
4619 
 
4620 
  def recv_savePaymentSettlements(self, ):
4621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4622 
    if mtype == TMessageType.EXCEPTION:
4623 
      x = TApplicationException()
4624 
      x.read(self._iprot)
4625 
      self._iprot.readMessageEnd()
4626 
      raise x
4627 
    result = savePaymentSettlements_result()
4628 
    result.read(self._iprot)
4629 
    self._iprot.readMessageEnd()
4630 
    if result.ex is not None:
4631 
      raise result.ex
4632 
    return
4633 
 
4634 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4635 
    """
4636 
    Parameters:
4637 
     - settlementId
4638 
     - settlementDate
4639 
     - transactionDateFrom
4640 
     - transactionDateTo
4641 
     - amount
4642 
    """
4643 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4644 
    self.recv_saveEBSSettlementSummary()
4645 
 
4646 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4647 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4648 
    args = saveEBSSettlementSummary_args()
4649 
    args.settlementId = settlementId
4650 
    args.settlementDate = settlementDate
4651 
    args.transactionDateFrom = transactionDateFrom
4652 
    args.transactionDateTo = transactionDateTo
4653 
    args.amount = amount
4654 
    args.write(self._oprot)
4655 
    self._oprot.writeMessageEnd()
4656 
    self._oprot.trans.flush()
4657 
 
4658 
  def recv_saveEBSSettlementSummary(self, ):
4659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4660 
    if mtype == TMessageType.EXCEPTION:
4661 
      x = TApplicationException()
4662 
      x.read(self._iprot)
4663 
      self._iprot.readMessageEnd()
4664 
      raise x
4665 
    result = saveEBSSettlementSummary_result()
4666 
    result.read(self._iprot)
4667 
    self._iprot.readMessageEnd()
4668 
    if result.ex is not None:
4669 
      raise result.ex
4670 
    return
4671 
 
5386 phani.kuma 4672 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4673 
    """
4674 
    Parameters:
5189 varun.gupt 4675 
     - referenceId
4676 
     - isRefund
4600 varun.gupt 4677 
    """
5386 phani.kuma 4678 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4679 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4680 
 
5386 phani.kuma 4681 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4682 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4683 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4684 
    args.referenceId = referenceId
4685 
    args.isRefund = isRefund
4600 varun.gupt 4686 
    args.write(self._oprot)
4687 
    self._oprot.writeMessageEnd()
4688 
    self._oprot.trans.flush()
4689 
 
5386 phani.kuma 4690 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4692 
    if mtype == TMessageType.EXCEPTION:
4693 
      x = TApplicationException()
4694 
      x.read(self._iprot)
4695 
      self._iprot.readMessageEnd()
4696 
      raise x
5386 phani.kuma 4697 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4698 
    result.read(self._iprot)
4699 
    self._iprot.readMessageEnd()
4700 
    if result.success is not None:
4701 
      return result.success
4702 
    if result.ex is not None:
4703 
      raise result.ex
5386 phani.kuma 4704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4705 
 
5386 phani.kuma 4706 
  def getSettlementForCod(self, orderId, isRefund):
4707 
    """
4708 
    Parameters:
4709 
     - orderId
4710 
     - isRefund
4711 
    """
4712 
    self.send_getSettlementForCod(orderId, isRefund)
4713 
    return self.recv_getSettlementForCod()
4714 
 
4715 
  def send_getSettlementForCod(self, orderId, isRefund):
4716 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4717 
    args = getSettlementForCod_args()
4718 
    args.orderId = orderId
4719 
    args.isRefund = isRefund
4720 
    args.write(self._oprot)
4721 
    self._oprot.writeMessageEnd()
4722 
    self._oprot.trans.flush()
4723 
 
4724 
  def recv_getSettlementForCod(self, ):
4725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4726 
    if mtype == TMessageType.EXCEPTION:
4727 
      x = TApplicationException()
4728 
      x.read(self._iprot)
4729 
      self._iprot.readMessageEnd()
4730 
      raise x
4731 
    result = getSettlementForCod_result()
4732 
    result.read(self._iprot)
4733 
    self._iprot.readMessageEnd()
4734 
    if result.success is not None:
4735 
      return result.success
4736 
    if result.ex is not None:
4737 
      raise result.ex
4738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4739 
 
4600 varun.gupt 4740 
  def getEBSSettlementSummaries(self, ):
4741 
    self.send_getEBSSettlementSummaries()
4742 
    return self.recv_getEBSSettlementSummaries()
4743 
 
4744 
  def send_getEBSSettlementSummaries(self, ):
4745 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4746 
    args = getEBSSettlementSummaries_args()
4747 
    args.write(self._oprot)
4748 
    self._oprot.writeMessageEnd()
4749 
    self._oprot.trans.flush()
4750 
 
4751 
  def recv_getEBSSettlementSummaries(self, ):
4752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4753 
    if mtype == TMessageType.EXCEPTION:
4754 
      x = TApplicationException()
4755 
      x.read(self._iprot)
4756 
      self._iprot.readMessageEnd()
4757 
      raise x
4758 
    result = getEBSSettlementSummaries_result()
4759 
    result.read(self._iprot)
4760 
    self._iprot.readMessageEnd()
4761 
    if result.success is not None:
4762 
      return result.success
4763 
    if result.ex is not None:
4764 
      raise result.ex
4765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4766 
 
4767 
  def markEBSSettlementUploaded(self, settlementId):
4768 
    """
4769 
    Parameters:
4770 
     - settlementId
4771 
    """
4772 
    self.send_markEBSSettlementUploaded(settlementId)
4773 
    self.recv_markEBSSettlementUploaded()
4774 
 
4775 
  def send_markEBSSettlementUploaded(self, settlementId):
4776 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4777 
    args = markEBSSettlementUploaded_args()
4778 
    args.settlementId = settlementId
4779 
    args.write(self._oprot)
4780 
    self._oprot.writeMessageEnd()
4781 
    self._oprot.trans.flush()
4782 
 
4783 
  def recv_markEBSSettlementUploaded(self, ):
4784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4785 
    if mtype == TMessageType.EXCEPTION:
4786 
      x = TApplicationException()
4787 
      x.read(self._iprot)
4788 
      self._iprot.readMessageEnd()
4789 
      raise x
4790 
    result = markEBSSettlementUploaded_result()
4791 
    result.read(self._iprot)
4792 
    self._iprot.readMessageEnd()
4793 
    if result.ex is not None:
4794 
      raise result.ex
4795 
    return
4796 
 
4797 
  def getEBSSettlementDate(self, settlementId):
4798 
    """
4799 
    Parameters:
4800 
     - settlementId
4801 
    """
4802 
    self.send_getEBSSettlementDate(settlementId)
4803 
    return self.recv_getEBSSettlementDate()
4804 
 
4805 
  def send_getEBSSettlementDate(self, settlementId):
4806 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4807 
    args = getEBSSettlementDate_args()
4808 
    args.settlementId = settlementId
4809 
    args.write(self._oprot)
4810 
    self._oprot.writeMessageEnd()
4811 
    self._oprot.trans.flush()
4812 
 
4813 
  def recv_getEBSSettlementDate(self, ):
4814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4815 
    if mtype == TMessageType.EXCEPTION:
4816 
      x = TApplicationException()
4817 
      x.read(self._iprot)
4818 
      self._iprot.readMessageEnd()
4819 
      raise x
4820 
    result = getEBSSettlementDate_result()
4821 
    result.read(self._iprot)
4822 
    self._iprot.readMessageEnd()
4823 
    if result.success is not None:
4824 
      return result.success
4825 
    if result.ex is not None:
4826 
      raise result.ex
4827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4828 
 
4715 varun.gupt 4829 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4830 
    """
4831 
    Parameters:
4832 
     - settlementDateFrom
4833 
     - settlementDateTo
4834 
     - isRefund
4835 
    """
4836 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4837 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4838 
 
4715 varun.gupt 4839 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4840 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4841 
    args = getSettlementsByDate_args()
4842 
    args.settlementDateFrom = settlementDateFrom
4843 
    args.settlementDateTo = settlementDateTo
4844 
    args.isRefund = isRefund
4845 
    args.write(self._oprot)
4846 
    self._oprot.writeMessageEnd()
4847 
    self._oprot.trans.flush()
4848 
 
4849 
  def recv_getSettlementsByDate(self, ):
4850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4851 
    if mtype == TMessageType.EXCEPTION:
4852 
      x = TApplicationException()
4853 
      x.read(self._iprot)
4854 
      self._iprot.readMessageEnd()
4855 
      raise x
4856 
    result = getSettlementsByDate_result()
4857 
    result.read(self._iprot)
4858 
    self._iprot.readMessageEnd()
4859 
    if result.success is not None:
4860 
      return result.success
4861 
    if result.ex is not None:
4862 
      raise result.ex
4863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4864 
 
4865 
  def getReshippedOrderIds(self, orderIds):
4866 
    """
4867 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4868 
 
4869 
    Parameters:
4870 
     - orderIds
4871 
    """
4872 
    self.send_getReshippedOrderIds(orderIds)
4873 
    return self.recv_getReshippedOrderIds()
4874 
 
4875 
  def send_getReshippedOrderIds(self, orderIds):
4876 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4877 
    args = getReshippedOrderIds_args()
4878 
    args.orderIds = orderIds
4879 
    args.write(self._oprot)
4880 
    self._oprot.writeMessageEnd()
4881 
    self._oprot.trans.flush()
4882 
 
4883 
  def recv_getReshippedOrderIds(self, ):
4884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4885 
    if mtype == TMessageType.EXCEPTION:
4886 
      x = TApplicationException()
4887 
      x.read(self._iprot)
4888 
      self._iprot.readMessageEnd()
4889 
      raise x
4890 
    result = getReshippedOrderIds_result()
4891 
    result.read(self._iprot)
4892 
    self._iprot.readMessageEnd()
4893 
    if result.success is not None:
4894 
      return result.success
4895 
    if result.ex is not None:
4896 
      raise result.ex
4897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4898 
 
4875 varun.gupt 4899 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4900 
    """
4901 
    Parameters:
4902 
     - vendorId
4903 
    """
4904 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4905 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4906 
 
4875 varun.gupt 4907 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4908 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4909 
    args = getOrdersWhereVendorNotPaid_args()
4910 
    args.vendorId = vendorId
4911 
    args.write(self._oprot)
4912 
    self._oprot.writeMessageEnd()
4913 
    self._oprot.trans.flush()
4914 
 
4915 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4917 
    if mtype == TMessageType.EXCEPTION:
4918 
      x = TApplicationException()
4919 
      x.read(self._iprot)
4920 
      self._iprot.readMessageEnd()
4921 
      raise x
4922 
    result = getOrdersWhereVendorNotPaid_result()
4923 
    result.read(self._iprot)
4924 
    self._iprot.readMessageEnd()
4925 
    if result.success is not None:
4926 
      return result.success
4927 
    if result.ex is not None:
4928 
      raise result.ex
4929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4930 
 
5031 varun.gupt 4931 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4932 
    """
4933 
    Parameters:
4934 
     - startDate
4935 
     - endDate
4936 
    """
4937 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4938 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4939 
 
5031 varun.gupt 4940 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4941 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4942 
    args = getStatusDistributionOfOrders_args()
4943 
    args.startDate = startDate
4944 
    args.endDate = endDate
4945 
    args.write(self._oprot)
4946 
    self._oprot.writeMessageEnd()
4947 
    self._oprot.trans.flush()
4948 
 
4949 
  def recv_getStatusDistributionOfOrders(self, ):
4950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4951 
    if mtype == TMessageType.EXCEPTION:
4952 
      x = TApplicationException()
4953 
      x.read(self._iprot)
4954 
      self._iprot.readMessageEnd()
4955 
      raise x
4956 
    result = getStatusDistributionOfOrders_result()
4957 
    result.read(self._iprot)
4958 
    self._iprot.readMessageEnd()
4959 
    if result.success is not None:
4960 
      return result.success
4961 
    if result.ex is not None:
4962 
      raise result.ex
4963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4964 
 
5067 varun.gupt 4965 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4966 
    """
4967 
    Parameters:
4968 
     - status
4969 
     - startDatetime
4970 
     - endDatetime
4971 
    """
4972 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4973 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4974 
 
5067 varun.gupt 4975 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4976 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4977 
    args = getOrderIdsForStatus_args()
4978 
    args.status = status
4979 
    args.startDatetime = startDatetime
4980 
    args.endDatetime = endDatetime
4981 
    args.write(self._oprot)
4982 
    self._oprot.writeMessageEnd()
4983 
    self._oprot.trans.flush()
4984 
 
4985 
  def recv_getOrderIdsForStatus(self, ):
4986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4987 
    if mtype == TMessageType.EXCEPTION:
4988 
      x = TApplicationException()
4989 
      x.read(self._iprot)
4990 
      self._iprot.readMessageEnd()
4991 
      raise x
4992 
    result = getOrderIdsForStatus_result()
4993 
    result.read(self._iprot)
4994 
    self._iprot.readMessageEnd()
4995 
    if result.success is not None:
4996 
      return result.success
4997 
    if result.ex is not None:
4998 
      raise result.ex
4999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5000 
 
5348 anupam.sin 5001 
  def updateCODAgent(self, agent, orderId):
5002 
    """
5003 
    Updates the agent who handled the COD verification call
5004 
 
5005 
    Parameters:
5006 
     - agent
5007 
     - orderId
5008 
    """
5009 
    self.send_updateCODAgent(agent, orderId)
5010 
    self.recv_updateCODAgent()
5011 
 
5012 
  def send_updateCODAgent(self, agent, orderId):
5013 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5014 
    args = updateCODAgent_args()
5015 
    args.agent = agent
5016 
    args.orderId = orderId
5017 
    args.write(self._oprot)
5018 
    self._oprot.writeMessageEnd()
5019 
    self._oprot.trans.flush()
5020 
 
5021 
  def recv_updateCODAgent(self, ):
5022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5023 
    if mtype == TMessageType.EXCEPTION:
5024 
      x = TApplicationException()
5025 
      x.read(self._iprot)
5026 
      self._iprot.readMessageEnd()
5027 
      raise x
5028 
    result = updateCODAgent_result()
5029 
    result.read(self._iprot)
5030 
    self._iprot.readMessageEnd()
5031 
    if result.ex is not None:
5032 
      raise result.ex
5033 
    return
5034 
 
5099 varun.gupt 5035 
  def updateOrderAsPaidToVendor(self, orderId):
5036 
    """
5037 
    Parameters:
5038 
     - orderId
5039 
    """
5040 
    self.send_updateOrderAsPaidToVendor(orderId)
5041 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5042 
 
5099 varun.gupt 5043 
  def send_updateOrderAsPaidToVendor(self, orderId):
5044 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5045 
    args = updateOrderAsPaidToVendor_args()
5046 
    args.orderId = orderId
5047 
    args.write(self._oprot)
5048 
    self._oprot.writeMessageEnd()
5049 
    self._oprot.trans.flush()
5050 
 
5051 
  def recv_updateOrderAsPaidToVendor(self, ):
5052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5053 
    if mtype == TMessageType.EXCEPTION:
5054 
      x = TApplicationException()
5055 
      x.read(self._iprot)
5056 
      self._iprot.readMessageEnd()
5057 
      raise x
5058 
    result = updateOrderAsPaidToVendor_result()
5059 
    result.read(self._iprot)
5060 
    self._iprot.readMessageEnd()
5061 
    if result.ex is not None:
5062 
      raise result.ex
5063 
    return
5064 
 
5386 phani.kuma 5065 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5066 
    """
5067 
    Parameters:
5068 
     - orderId
5069 
    """
5070 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5071 
    self.recv_updateOrderOnlyAsPaidToVendor()
5072 
 
5073 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5074 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5075 
    args = updateOrderOnlyAsPaidToVendor_args()
5076 
    args.orderId = orderId
5077 
    args.write(self._oprot)
5078 
    self._oprot.writeMessageEnd()
5079 
    self._oprot.trans.flush()
5080 
 
5081 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5083 
    if mtype == TMessageType.EXCEPTION:
5084 
      x = TApplicationException()
5085 
      x.read(self._iprot)
5086 
      self._iprot.readMessageEnd()
5087 
      raise x
5088 
    result = updateOrderOnlyAsPaidToVendor_result()
5089 
    result.read(self._iprot)
5090 
    self._iprot.readMessageEnd()
5091 
    if result.ex is not None:
5092 
      raise result.ex
5093 
    return
5094 
 
5208 varun.gupt 5095 
  def getRefundedOrdersMarkedPaid(self, ):
5096 
    self.send_getRefundedOrdersMarkedPaid()
5097 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5098 
 
5208 varun.gupt 5099 
  def send_getRefundedOrdersMarkedPaid(self, ):
5100 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5101 
    args = getRefundedOrdersMarkedPaid_args()
5102 
    args.write(self._oprot)
5103 
    self._oprot.writeMessageEnd()
5104 
    self._oprot.trans.flush()
5105 
 
5106 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5108 
    if mtype == TMessageType.EXCEPTION:
5109 
      x = TApplicationException()
5110 
      x.read(self._iprot)
5111 
      self._iprot.readMessageEnd()
5112 
      raise x
5113 
    result = getRefundedOrdersMarkedPaid_result()
5114 
    result.read(self._iprot)
5115 
    self._iprot.readMessageEnd()
5116 
    if result.success is not None:
5117 
      return result.success
5118 
    if result.ex is not None:
5119 
      raise result.ex
5120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5121 
 
5122 
 
3376 rajveer 5123 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5124 
  def __init__(self, handler):
3376 rajveer 5125 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5126 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5127 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5128 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5129 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5130 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5131 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5132 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5133 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5134 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5135 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5136 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5137 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5138 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5139 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5140 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5141 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5142 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5143 
    self._processMap["createOrder"] = Processor.process_createOrder
5144 
    self._processMap["getOrder"] = Processor.process_getOrder
5145 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5146 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5147 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5148 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5149 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5150 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5151 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5152 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5153 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5154 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5155 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5156 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5157 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5158 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5159 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5160 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5161 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5162 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5163 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5164 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5165 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5166 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5167 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5168 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5169 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5170 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5171 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5172 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5173 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5174 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5175 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5176 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5177 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5178 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5179 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5180 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5181 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5182 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5183 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5184 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5185 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5186 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5187 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5188 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5189 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5190 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5191 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5192 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5193 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5194 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5195 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5196 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5197 
    self._processMap["changeItem"] = Processor.process_changeItem
5198 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5199 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5200 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5201 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5202 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5203 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5204 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5205 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5206 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5207 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5208 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5209 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5210 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5211 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5212 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5213 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5214 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5215 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5216 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5217 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5218 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5219 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5220 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5221 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5222 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5223 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5224 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5225 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5226 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5227 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5228 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5229 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5230 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5231 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4875 varun.gupt 5232 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5233 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5234 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5235 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5236 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5237 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5238 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5239 
 
5240 
  def process(self, iprot, oprot):
5241 
    (name, type, seqid) = iprot.readMessageBegin()
5242 
    if name not in self._processMap:
5243 
      iprot.skip(TType.STRUCT)
5244 
      iprot.readMessageEnd()
5245 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5246 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5247 
      x.write(oprot)
5248 
      oprot.writeMessageEnd()
5249 
      oprot.trans.flush()
5250 
      return
5251 
    else:
5252 
      self._processMap[name](self, seqid, iprot, oprot)
5253 
    return True
5254 
 
5255 
  def process_createTransaction(self, seqid, iprot, oprot):
5256 
    args = createTransaction_args()
5257 
    args.read(iprot)
5258 
    iprot.readMessageEnd()
5259 
    result = createTransaction_result()
5260 
    try:
132 ashish 5261 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5262 
    except TransactionServiceException, ex:
5263 
      result.ex = ex
5264 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5265 
    result.write(oprot)
5266 
    oprot.writeMessageEnd()
5267 
    oprot.trans.flush()
5268 
 
5269 
  def process_getTransaction(self, seqid, iprot, oprot):
5270 
    args = getTransaction_args()
5271 
    args.read(iprot)
5272 
    iprot.readMessageEnd()
5273 
    result = getTransaction_result()
5274 
    try:
5275 
      result.success = self._handler.getTransaction(args.id)
5276 
    except TransactionServiceException, ex:
5277 
      result.ex = ex
5278 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5279 
    result.write(oprot)
5280 
    oprot.writeMessageEnd()
5281 
    oprot.trans.flush()
5282 
 
5283 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5284 
    args = getTransactionsForCustomer_args()
5285 
    args.read(iprot)
5286 
    iprot.readMessageEnd()
5287 
    result = getTransactionsForCustomer_result()
5288 
    try:
5289 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5290 
    except TransactionServiceException, ex:
5291 
      result.ex = ex
5292 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5293 
    result.write(oprot)
5294 
    oprot.writeMessageEnd()
5295 
    oprot.trans.flush()
5296 
 
132 ashish 5297 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5298 
    args = getTransactionsForShoppingCartId_args()
5299 
    args.read(iprot)
5300 
    iprot.readMessageEnd()
5301 
    result = getTransactionsForShoppingCartId_result()
5302 
    try:
5303 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5304 
    except TransactionServiceException, ex:
5305 
      result.ex = ex
5306 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5307 
    result.write(oprot)
5308 
    oprot.writeMessageEnd()
5309 
    oprot.trans.flush()
5310 
 
94 ashish 5311 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5312 
    args = getTransactionStatus_args()
5313 
    args.read(iprot)
5314 
    iprot.readMessageEnd()
5315 
    result = getTransactionStatus_result()
5316 
    try:
5317 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5318 
    except TransactionServiceException, ex:
5319 
      result.ex = ex
5320 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
5325 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5326 
    args = changeTransactionStatus_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = changeTransactionStatus_result()
5330 
    try:
5331 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5332 
    except TransactionServiceException, ex:
5333 
      result.ex = ex
5334 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5335 
    result.write(oprot)
5336 
    oprot.writeMessageEnd()
5337 
    oprot.trans.flush()
5338 
 
1398 varun.gupt 5339 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5340 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5341 
    args.read(iprot)
5342 
    iprot.readMessageEnd()
1398 varun.gupt 5343 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5344 
    try:
1398 varun.gupt 5345 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5346 
    except TransactionServiceException, ex:
5347 
      result.ex = ex
1398 varun.gupt 5348 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5349 
    result.write(oprot)
5350 
    oprot.writeMessageEnd()
5351 
    oprot.trans.flush()
5352 
 
483 rajveer 5353 
  def process_getAllOrders(self, seqid, iprot, oprot):
5354 
    args = getAllOrders_args()
94 ashish 5355 
    args.read(iprot)
5356 
    iprot.readMessageEnd()
483 rajveer 5357 
    result = getAllOrders_result()
94 ashish 5358 
    try:
4801 anupam.sin 5359 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5360 
    except TransactionServiceException, ex:
5361 
      result.ex = ex
483 rajveer 5362 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5363 
    result.write(oprot)
5364 
    oprot.writeMessageEnd()
5365 
    oprot.trans.flush()
5366 
 
4133 chandransh 5367 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5368 
    args = getOrdersInBatch_args()
5369 
    args.read(iprot)
5370 
    iprot.readMessageEnd()
5371 
    result = getOrdersInBatch_result()
5372 
    try:
5373 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5374 
    except TransactionServiceException, ex:
5375 
      result.ex = ex
5376 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5377 
    result.write(oprot)
5378 
    oprot.writeMessageEnd()
5379 
    oprot.trans.flush()
5380 
 
5381 
  def process_getOrderCount(self, seqid, iprot, oprot):
5382 
    args = getOrderCount_args()
5383 
    args.read(iprot)
5384 
    iprot.readMessageEnd()
5385 
    result = getOrderCount_result()
5386 
    try:
5387 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5388 
    except TransactionServiceException, ex:
5389 
      result.ex = ex
5390 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
5394 
 
999 varun.gupt 5395 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5396 
    args = getOrdersByBillingDate_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = getOrdersByBillingDate_result()
5400 
    try:
5401 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5402 
    except TransactionServiceException, ex:
5403 
      result.ex = ex
5404 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5405 
    result.write(oprot)
5406 
    oprot.writeMessageEnd()
5407 
    oprot.trans.flush()
5408 
 
3427 chandransh 5409 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5410 
    args = getOrdersByShippingDate_args()
5411 
    args.read(iprot)
5412 
    iprot.readMessageEnd()
5413 
    result = getOrdersByShippingDate_result()
5414 
    try:
3451 chandransh 5415 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5416 
    except TransactionServiceException, ex:
5417 
      result.ex = ex
5418 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5419 
    result.write(oprot)
5420 
    oprot.writeMessageEnd()
5421 
    oprot.trans.flush()
5422 
 
1382 varun.gupt 5423 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5424 
    args = getReturnableOrdersForCustomer_args()
5425 
    args.read(iprot)
5426 
    iprot.readMessageEnd()
5427 
    result = getReturnableOrdersForCustomer_result()
5428 
    try:
5429 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5430 
    except TransactionServiceException, ex:
5431 
      result.ex = ex
5432 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5433 
    result.write(oprot)
5434 
    oprot.writeMessageEnd()
5435 
    oprot.trans.flush()
5436 
 
5437 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5438 
    args = getCancellableOrdersForCustomer_args()
5439 
    args.read(iprot)
5440 
    iprot.readMessageEnd()
5441 
    result = getCancellableOrdersForCustomer_result()
5442 
    try:
5443 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5444 
    except TransactionServiceException, ex:
5445 
      result.ex = ex
5446 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5447 
    result.write(oprot)
5448 
    oprot.writeMessageEnd()
5449 
    oprot.trans.flush()
5450 
 
483 rajveer 5451 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5452 
    args = changeOrderStatus_args()
94 ashish 5453 
    args.read(iprot)
5454 
    iprot.readMessageEnd()
483 rajveer 5455 
    result = changeOrderStatus_result()
94 ashish 5456 
    try:
483 rajveer 5457 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5458 
    except TransactionServiceException, ex:
5459 
      result.ex = ex
483 rajveer 5460 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5461 
    result.write(oprot)
5462 
    oprot.writeMessageEnd()
5463 
    oprot.trans.flush()
5464 
 
483 rajveer 5465 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5466 
    args = getOrdersForTransaction_args()
94 ashish 5467 
    args.read(iprot)
5468 
    iprot.readMessageEnd()
483 rajveer 5469 
    result = getOrdersForTransaction_result()
94 ashish 5470 
    try:
1528 ankur.sing 5471 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5472 
    except TransactionServiceException, ex:
5473 
      result.ex = ex
483 rajveer 5474 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5475 
    result.write(oprot)
5476 
    oprot.writeMessageEnd()
5477 
    oprot.trans.flush()
5478 
 
483 rajveer 5479 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5480 
    args = getOrdersForCustomer_args()
94 ashish 5481 
    args.read(iprot)
5482 
    iprot.readMessageEnd()
483 rajveer 5483 
    result = getOrdersForCustomer_result()
94 ashish 5484 
    try:
3014 chandransh 5485 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5486 
    except TransactionServiceException, ex:
5487 
      result.ex = ex
483 rajveer 5488 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5489 
    result.write(oprot)
5490 
    oprot.writeMessageEnd()
5491 
    oprot.trans.flush()
5492 
 
483 rajveer 5493 
  def process_createOrder(self, seqid, iprot, oprot):
5494 
    args = createOrder_args()
94 ashish 5495 
    args.read(iprot)
5496 
    iprot.readMessageEnd()
483 rajveer 5497 
    result = createOrder_result()
94 ashish 5498 
    try:
483 rajveer 5499 
      result.success = self._handler.createOrder(args.order)
94 ashish 5500 
    except TransactionServiceException, ex:
5501 
      result.ex = ex
483 rajveer 5502 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5503 
    result.write(oprot)
5504 
    oprot.writeMessageEnd()
5505 
    oprot.trans.flush()
5506 
 
483 rajveer 5507 
  def process_getOrder(self, seqid, iprot, oprot):
5508 
    args = getOrder_args()
94 ashish 5509 
    args.read(iprot)
5510 
    iprot.readMessageEnd()
483 rajveer 5511 
    result = getOrder_result()
94 ashish 5512 
    try:
483 rajveer 5513 
      result.success = self._handler.getOrder(args.id)
94 ashish 5514 
    except TransactionServiceException, ex:
5515 
      result.ex = ex
483 rajveer 5516 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5517 
    result.write(oprot)
5518 
    oprot.writeMessageEnd()
5519 
    oprot.trans.flush()
5520 
 
483 rajveer 5521 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5522 
    args = getLineItemsForOrder_args()
94 ashish 5523 
    args.read(iprot)
5524 
    iprot.readMessageEnd()
483 rajveer 5525 
    result = getLineItemsForOrder_result()
94 ashish 5526 
    try:
483 rajveer 5527 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5528 
    except TransactionServiceException, ex:
5529 
      result.ex = ex
483 rajveer 5530 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5531 
    result.write(oprot)
5532 
    oprot.writeMessageEnd()
5533 
    oprot.trans.flush()
5534 
 
4999 phani.kuma 5535 
  def process_getOrderList(self, seqid, iprot, oprot):
5536 
    args = getOrderList_args()
5537 
    args.read(iprot)
5538 
    iprot.readMessageEnd()
5539 
    result = getOrderList_result()
5540 
    result.success = self._handler.getOrderList(args.order_ids)
5541 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5542 
    result.write(oprot)
5543 
    oprot.writeMessageEnd()
5544 
    oprot.trans.flush()
5545 
 
5386 phani.kuma 5546 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5547 
    args = getOrderListForVendor_args()
5548 
    args.read(iprot)
5549 
    iprot.readMessageEnd()
5550 
    result = getOrderListForVendor_result()
5551 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5552 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5553 
    result.write(oprot)
5554 
    oprot.writeMessageEnd()
5555 
    oprot.trans.flush()
5556 
 
1528 ankur.sing 5557 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5558 
    args = getOrderForCustomer_args()
5559 
    args.read(iprot)
5560 
    iprot.readMessageEnd()
5561 
    result = getOrderForCustomer_result()
5562 
    try:
5563 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5564 
    except TransactionServiceException, ex:
5565 
      result.ex = ex
5566 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
3064 chandransh 5571 
  def process_getAlerts(self, seqid, iprot, oprot):
5572 
    args = getAlerts_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = getAlerts_result()
4444 rajveer 5576 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5577 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
4394 rajveer 5582 
  def process_addAlert(self, seqid, iprot, oprot):
5583 
    args = addAlert_args()
3064 chandransh 5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
4394 rajveer 5586 
    result = addAlert_result()
4444 rajveer 5587 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5588 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
5592 
 
4444 rajveer 5593 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5594 
    args = markAlertsAsSeen_args()
5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
5597 
    result = markAlertsAsSeen_result()
5598 
    self._handler.markAlertsAsSeen(args.warehouseId)
5599 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5600 
    result.write(oprot)
5601 
    oprot.writeMessageEnd()
5602 
    oprot.trans.flush()
5603 
 
3064 chandransh 5604 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5605 
    args = getValidOrderCount_args()
5606 
    args.read(iprot)
5607 
    iprot.readMessageEnd()
5608 
    result = getValidOrderCount_result()
5609 
    result.success = self._handler.getValidOrderCount()
5610 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5611 
    result.write(oprot)
5612 
    oprot.writeMessageEnd()
5613 
    oprot.trans.flush()
5614 
 
5615 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5616 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5617 
    args.read(iprot)
5618 
    iprot.readMessageEnd()
5619 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5620 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5621 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5622 
    result.write(oprot)
5623 
    oprot.writeMessageEnd()
5624 
    oprot.trans.flush()
5625 
 
5626 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5627 
    args = getValidOrdersAmountRange_args()
5628 
    args.read(iprot)
5629 
    iprot.readMessageEnd()
5630 
    result = getValidOrdersAmountRange_result()
5631 
    result.success = self._handler.getValidOrdersAmountRange()
5632 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5633 
    result.write(oprot)
5634 
    oprot.writeMessageEnd()
5635 
    oprot.trans.flush()
5636 
 
5637 
  def process_getValidOrders(self, seqid, iprot, oprot):
5638 
    args = getValidOrders_args()
5639 
    args.read(iprot)
5640 
    iprot.readMessageEnd()
5641 
    result = getValidOrders_result()
5642 
    result.success = self._handler.getValidOrders(args.limit)
5643 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5644 
    result.write(oprot)
5645 
    oprot.writeMessageEnd()
5646 
    oprot.trans.flush()
5647 
 
1220 chandransh 5648 
  def process_batchOrders(self, seqid, iprot, oprot):
5649 
    args = batchOrders_args()
5650 
    args.read(iprot)
5651 
    iprot.readMessageEnd()
5652 
    result = batchOrders_result()
5653 
    try:
5654 
      result.success = self._handler.batchOrders(args.warehouseId)
5655 
    except TransactionServiceException, ex:
5656 
      result.ex = ex
5657 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5658 
    result.write(oprot)
5659 
    oprot.writeMessageEnd()
5660 
    oprot.trans.flush()
5661 
 
1208 chandransh 5662 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5663 
    args = markOrderAsOutOfStock_args()
5664 
    args.read(iprot)
5665 
    iprot.readMessageEnd()
5666 
    result = markOrderAsOutOfStock_result()
5667 
    try:
5668 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5669 
    except TransactionServiceException, ex:
5670 
      result.ex = ex
5671 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5672 
    result.write(oprot)
5673 
    oprot.writeMessageEnd()
5674 
    oprot.trans.flush()
5675 
 
3064 chandransh 5676 
  def process_verifyOrder(self, seqid, iprot, oprot):
5677 
    args = verifyOrder_args()
759 chandransh 5678 
    args.read(iprot)
5679 
    iprot.readMessageEnd()
3064 chandransh 5680 
    result = verifyOrder_result()
759 chandransh 5681 
    try:
3064 chandransh 5682 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5683 
    except TransactionServiceException, ex:
5684 
      result.ex = ex
3064 chandransh 5685 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5686 
    result.write(oprot)
5687 
    oprot.writeMessageEnd()
5688 
    oprot.trans.flush()
5689 
 
3064 chandransh 5690 
  def process_acceptOrder(self, seqid, iprot, oprot):
5691 
    args = acceptOrder_args()
1113 chandransh 5692 
    args.read(iprot)
5693 
    iprot.readMessageEnd()
3064 chandransh 5694 
    result = acceptOrder_result()
1113 chandransh 5695 
    try:
3064 chandransh 5696 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5697 
    except TransactionServiceException, ex:
5698 
      result.ex = ex
3064 chandransh 5699 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5700 
    result.write(oprot)
5701 
    oprot.writeMessageEnd()
5702 
    oprot.trans.flush()
5703 
 
3064 chandransh 5704 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5705 
    args = addBillingDetails_args()
1135 chandransh 5706 
    args.read(iprot)
5707 
    iprot.readMessageEnd()
3064 chandransh 5708 
    result = addBillingDetails_result()
1135 chandransh 5709 
    try:
5110 mandeep.dh 5710 
      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 5711 
    except TransactionServiceException, ex:
5712 
      result.ex = ex
3064 chandransh 5713 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5714 
    result.write(oprot)
5715 
    oprot.writeMessageEnd()
5716 
    oprot.trans.flush()
5717 
 
4579 rajveer 5718 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5719 
    args = addInvoiceNumber_args()
5720 
    args.read(iprot)
5721 
    iprot.readMessageEnd()
5722 
    result = addInvoiceNumber_result()
5723 
    try:
4763 rajveer 5724 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5725 
    except TransactionServiceException, ex:
5726 
      result.ex = ex
5727 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
5731 
 
4410 rajveer 5732 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5733 
    args = markOrdersAsShippedFromWarehouse_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = markOrdersAsShippedFromWarehouse_result()
5737 
    try:
4789 rajveer 5738 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5739 
    except TransactionServiceException, ex:
5740 
      result.ex = ex
5741 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
3064 chandransh 5746 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5747 
    args = markOrdersAsPickedUp_args()
304 ashish 5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
3064 chandransh 5750 
    result = markOrdersAsPickedUp_result()
5751 
    try:
4910 phani.kuma 5752 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5753 
    except TransactionServiceException, ex:
5754 
      result.ex = ex
5755 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
94 ashish 5759 
 
4910 phani.kuma 5760 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5761 
    args = getOrdersNotPickedUp_args()
5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
5764 
    result = getOrdersNotPickedUp_result()
5765 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5766 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5767 
    result.write(oprot)
5768 
    oprot.writeMessageEnd()
5769 
    oprot.trans.flush()
5770 
 
3064 chandransh 5771 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5772 
    args = markOrdersAsDelivered_args()
304 ashish 5773 
    args.read(iprot)
5774 
    iprot.readMessageEnd()
3064 chandransh 5775 
    result = markOrdersAsDelivered_result()
5776 
    try:
5777 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5778 
    except TransactionServiceException, ex:
5779 
      result.ex = ex
5780 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5781 
    result.write(oprot)
5782 
    oprot.writeMessageEnd()
5783 
    oprot.trans.flush()
5784 
 
4910 phani.kuma 5785 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5786 
    args = markAsRTOrders_args()
1596 ankur.sing 5787 
    args.read(iprot)
5788 
    iprot.readMessageEnd()
4910 phani.kuma 5789 
    result = markAsRTOrders_result()
3064 chandransh 5790 
    try:
4910 phani.kuma 5791 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5792 
    except TransactionServiceException, ex:
5793 
      result.ex = ex
4910 phani.kuma 5794 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5795 
    result.write(oprot)
5796 
    oprot.writeMessageEnd()
5797 
    oprot.trans.flush()
304 ashish 5798 
 
4910 phani.kuma 5799 
  def process_getRTOrders(self, seqid, iprot, oprot):
5800 
    args = getRTOrders_args()
5801 
    args.read(iprot)
5802 
    iprot.readMessageEnd()
5803 
    result = getRTOrders_result()
5804 
    result.success = self._handler.getRTOrders(args.providerId)
5805 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5806 
    result.write(oprot)
5807 
    oprot.writeMessageEnd()
5808 
    oprot.trans.flush()
5809 
 
3064 chandransh 5810 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5811 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5812 
    args.read(iprot)
5813 
    iprot.readMessageEnd()
3064 chandransh 5814 
    result = updateNonDeliveryReason_result()
5815 
    try:
4910 phani.kuma 5816 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5817 
    except TransactionServiceException, ex:
5818 
      result.ex = ex
5819 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5820 
    result.write(oprot)
5821 
    oprot.writeMessageEnd()
5822 
    oprot.trans.flush()
1596 ankur.sing 5823 
 
4910 phani.kuma 5824 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5825 
    args = getNonDeliveredOrdersbyCourier_args()
5826 
    args.read(iprot)
5827 
    iprot.readMessageEnd()
5828 
    result = getNonDeliveredOrdersbyCourier_result()
5829 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5830 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5831 
    result.write(oprot)
5832 
    oprot.writeMessageEnd()
5833 
    oprot.trans.flush()
5834 
 
5835 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5836 
    args = markOrdersAsLocalConnected_args()
5837 
    args.read(iprot)
5838 
    iprot.readMessageEnd()
5839 
    result = markOrdersAsLocalConnected_result()
5840 
    try:
5841 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5842 
    except TransactionServiceException, ex:
5843 
      result.ex = ex
5844 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5845 
    result.write(oprot)
5846 
    oprot.writeMessageEnd()
5847 
    oprot.trans.flush()
5848 
 
5849 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5850 
    args = getOrdersNotLocalConnected_args()
5851 
    args.read(iprot)
5852 
    iprot.readMessageEnd()
5853 
    result = getOrdersNotLocalConnected_result()
5854 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5855 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
5860 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5861 
    args = markOrdersAsDestinationCityReached_args()
5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
5864 
    result = markOrdersAsDestinationCityReached_result()
5865 
    try:
5866 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5867 
    except TransactionServiceException, ex:
5868 
      result.ex = ex
5869 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
5873 
 
5874 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5875 
    args = markOrdersAsFirstDeliveryAttempted_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = markOrdersAsFirstDeliveryAttempted_result()
5879 
    try:
5880 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5881 
    except TransactionServiceException, ex:
5882 
      result.ex = ex
5883 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5884 
    result.write(oprot)
5885 
    oprot.writeMessageEnd()
5886 
    oprot.trans.flush()
5887 
 
3064 chandransh 5888 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5889 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5890 
    args.read(iprot)
5891 
    iprot.readMessageEnd()
3064 chandransh 5892 
    result = getUndeliveredOrders_result()
5893 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5894 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5895 
    result.write(oprot)
5896 
    oprot.writeMessageEnd()
5897 
    oprot.trans.flush()
5898 
 
4783 phani.kuma 5899 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5900 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5901 
    args.read(iprot)
5902 
    iprot.readMessageEnd()
5903 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5904 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5905 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5906 
    result.write(oprot)
5907 
    oprot.writeMessageEnd()
5908 
    oprot.trans.flush()
5909 
 
2536 chandransh 5910 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5911 
    args = toggleDOAFlag_args()
5912 
    args.read(iprot)
5913 
    iprot.readMessageEnd()
5914 
    result = toggleDOAFlag_result()
5915 
    try:
5916 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5917 
    except TransactionServiceException, ex:
5918 
      result.ex = ex
5919 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5920 
    result.write(oprot)
5921 
    oprot.writeMessageEnd()
5922 
    oprot.trans.flush()
1886 ankur.sing 5923 
 
4712 rajveer 5924 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5925 
    args = markOrderAsDelivered_args()
5926 
    args.read(iprot)
5927 
    iprot.readMessageEnd()
5928 
    result = markOrderAsDelivered_result()
5929 
    try:
5930 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5931 
    except TransactionServiceException, ex:
5932 
      result.ex = ex
5933 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5934 
    result.write(oprot)
5935 
    oprot.writeMessageEnd()
5936 
    oprot.trans.flush()
5937 
 
4454 rajveer 5938 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5939 
    args = markOrderDoaRequestReceived_args()
5940 
    args.read(iprot)
5941 
    iprot.readMessageEnd()
5942 
    result = markOrderDoaRequestReceived_result()
5943 
    try:
5944 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5945 
    except TransactionServiceException, ex:
5946 
      result.ex = ex
5947 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5948 
    result.write(oprot)
5949 
    oprot.writeMessageEnd()
5950 
    oprot.trans.flush()
5951 
 
5952 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5953 
    args = markOrderDoaRequestAuthorized_args()
5954 
    args.read(iprot)
5955 
    iprot.readMessageEnd()
5956 
    result = markOrderDoaRequestAuthorized_result()
5957 
    try:
5958 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5959 
    except TransactionServiceException, ex:
5960 
      result.ex = ex
5961 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5962 
    result.write(oprot)
5963 
    oprot.writeMessageEnd()
5964 
    oprot.trans.flush()
5965 
 
4488 rajveer 5966 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5967 
    args = markOrderReturnRequestReceived_args()
5968 
    args.read(iprot)
5969 
    iprot.readMessageEnd()
5970 
    result = markOrderReturnRequestReceived_result()
5971 
    try:
5972 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5973 
    except TransactionServiceException, ex:
5974 
      result.ex = ex
5975 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5976 
    result.write(oprot)
5977 
    oprot.writeMessageEnd()
5978 
    oprot.trans.flush()
5979 
 
5980 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5981 
    args = markOrderReturnRequestAuthorized_args()
5982 
    args.read(iprot)
5983 
    iprot.readMessageEnd()
5984 
    result = markOrderReturnRequestAuthorized_result()
5985 
    try:
5986 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5987 
    except TransactionServiceException, ex:
5988 
      result.ex = ex
5989 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
5993 
 
2536 chandransh 5994 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5995 
    args = requestPickupNumber_args()
5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
5998 
    result = requestPickupNumber_result()
5999 
    try:
4579 rajveer 6000 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6001 
    except TransactionServiceException, ex:
6002 
      result.ex = ex
6003 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6004 
    result.write(oprot)
6005 
    oprot.writeMessageEnd()
6006 
    oprot.trans.flush()
6007 
 
6008 
  def process_authorizePickup(self, seqid, iprot, oprot):
6009 
    args = authorizePickup_args()
6010 
    args.read(iprot)
6011 
    iprot.readMessageEnd()
6012 
    result = authorizePickup_result()
6013 
    try:
4602 rajveer 6014 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6015 
    except TransactionServiceException, ex:
6016 
      result.ex = ex
6017 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6018 
    result.write(oprot)
6019 
    oprot.writeMessageEnd()
6020 
    oprot.trans.flush()
6021 
 
2764 chandransh 6022 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6023 
    args = markDoasAsPickedUp_args()
6024 
    args.read(iprot)
6025 
    iprot.readMessageEnd()
6026 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6027 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6028 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6029 
    result.write(oprot)
6030 
    oprot.writeMessageEnd()
6031 
    oprot.trans.flush()
6032 
 
4910 phani.kuma 6033 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6034 
    args = getDoasNotPickedUp_args()
6035 
    args.read(iprot)
6036 
    iprot.readMessageEnd()
6037 
    result = getDoasNotPickedUp_result()
6038 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6039 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
4741 phani.kuma 6044 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6045 
    args = markReturnOrdersAsPickedUp_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6049 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6050 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6051 
    result.write(oprot)
6052 
    oprot.writeMessageEnd()
6053 
    oprot.trans.flush()
6054 
 
4910 phani.kuma 6055 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6056 
    args = getReturnOrdersNotPickedUp_args()
6057 
    args.read(iprot)
6058 
    iprot.readMessageEnd()
6059 
    result = getReturnOrdersNotPickedUp_result()
6060 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6061 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6062 
    result.write(oprot)
6063 
    oprot.writeMessageEnd()
6064 
    oprot.trans.flush()
6065 
 
2616 chandransh 6066 
  def process_receiveReturn(self, seqid, iprot, oprot):
6067 
    args = receiveReturn_args()
2591 chandransh 6068 
    args.read(iprot)
6069 
    iprot.readMessageEnd()
2616 chandransh 6070 
    result = receiveReturn_result()
2591 chandransh 6071 
    try:
4479 rajveer 6072 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6073 
    except TransactionServiceException, ex:
6074 
      result.ex = ex
2616 chandransh 6075 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6076 
    result.write(oprot)
6077 
    oprot.writeMessageEnd()
6078 
    oprot.trans.flush()
2536 chandransh 6079 
 
2591 chandransh 6080 
  def process_validateDoa(self, seqid, iprot, oprot):
6081 
    args = validateDoa_args()
6082 
    args.read(iprot)
6083 
    iprot.readMessageEnd()
6084 
    result = validateDoa_result()
6085 
    try:
6086 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6087 
    except TransactionServiceException, ex:
6088 
      result.ex = ex
6089 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6090 
    result.write(oprot)
6091 
    oprot.writeMessageEnd()
6092 
    oprot.trans.flush()
6093 
 
4495 rajveer 6094 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6095 
    args = validateReturnProduct_args()
6096 
    args.read(iprot)
6097 
    iprot.readMessageEnd()
6098 
    result = validateReturnProduct_result()
6099 
    try:
6100 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6101 
    except TransactionServiceException, ex:
6102 
      result.ex = ex
6103 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6104 
    result.write(oprot)
6105 
    oprot.writeMessageEnd()
6106 
    oprot.trans.flush()
6107 
 
2616 chandransh 6108 
  def process_reshipOrder(self, seqid, iprot, oprot):
6109 
    args = reshipOrder_args()
6110 
    args.read(iprot)
6111 
    iprot.readMessageEnd()
6112 
    result = reshipOrder_result()
6113 
    try:
6114 
      result.success = self._handler.reshipOrder(args.orderId)
6115 
    except TransactionServiceException, ex:
6116 
      result.ex = ex
6117 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6118 
    result.write(oprot)
6119 
    oprot.writeMessageEnd()
6120 
    oprot.trans.flush()
2591 chandransh 6121 
 
2616 chandransh 6122 
  def process_refundOrder(self, seqid, iprot, oprot):
6123 
    args = refundOrder_args()
6124 
    args.read(iprot)
6125 
    iprot.readMessageEnd()
6126 
    result = refundOrder_result()
6127 
    try:
3226 chandransh 6128 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6129 
    except TransactionServiceException, ex:
6130 
      result.ex = ex
6131 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
6135 
 
2690 chandransh 6136 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6137 
    args = getReturnOrders_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = getReturnOrders_result()
6141 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6142 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
2616 chandransh 6146 
 
2700 chandransh 6147 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6148 
    args = getReturnOrder_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = getReturnOrder_result()
6152 
    try:
6153 
      result.success = self._handler.getReturnOrder(args.id)
6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
2690 chandransh 6161 
  def process_processReturn(self, seqid, iprot, oprot):
6162 
    args = processReturn_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = processReturn_result()
6166 
    try:
6167 
      self._handler.processReturn(args.returnOrderId)
6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
6170 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
3451 chandransh 6175 
  def process_updateWeight(self, seqid, iprot, oprot):
6176 
    args = updateWeight_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = updateWeight_result()
6180 
    try:
6181 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
6184 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
2819 chandransh 6188 
 
3469 chandransh 6189 
  def process_changeItem(self, seqid, iprot, oprot):
6190 
    args = changeItem_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = changeItem_result()
6194 
    try:
6195 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
6198 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
3451 chandransh 6202 
 
3469 chandransh 6203 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6204 
    args = shiftToWarehouse_args()
6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
6207 
    result = shiftToWarehouse_result()
6208 
    try:
6209 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
6212 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
3553 chandransh 6217 
  def process_addDelayReason(self, seqid, iprot, oprot):
6218 
    args = addDelayReason_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = addDelayReason_result()
6222 
    try:
4647 rajveer 6223 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6224 
    except TransactionServiceException, ex:
6225 
      result.ex = ex
6226 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
3469 chandransh 6230 
 
3956 chandransh 6231 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6232 
    args = reconcileCodCollection_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = reconcileCodCollection_result()
6236 
    try:
6237 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6238 
    except TransactionServiceException, ex:
6239 
      result.ex = ex
6240 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
3553 chandransh 6244 
 
4008 mandeep.dh 6245 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6246 
    args = getTransactionsRequiringExtraProcessing_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = getTransactionsRequiringExtraProcessing_result()
6250 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6251 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6252 
    result.write(oprot)
6253 
    oprot.writeMessageEnd()
6254 
    oprot.trans.flush()
3956 chandransh 6255 
 
4008 mandeep.dh 6256 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6257 
    args = markTransactionAsProcessed_args()
6258 
    args.read(iprot)
6259 
    iprot.readMessageEnd()
6260 
    result = markTransactionAsProcessed_result()
6261 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6262 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6263 
    result.write(oprot)
6264 
    oprot.writeMessageEnd()
6265 
    oprot.trans.flush()
6266 
 
4018 chandransh 6267 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6268 
    args = getItemWiseRiskyOrdersCount_args()
6269 
    args.read(iprot)
6270 
    iprot.readMessageEnd()
6271 
    result = getItemWiseRiskyOrdersCount_result()
6272 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6273 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6274 
    result.write(oprot)
6275 
    oprot.writeMessageEnd()
6276 
    oprot.trans.flush()
4008 mandeep.dh 6277 
 
4295 varun.gupt 6278 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6279 
    args = getOrdersForItemIds_args()
6280 
    args.read(iprot)
6281 
    iprot.readMessageEnd()
6282 
    result = getOrdersForItemIds_result()
6283 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6284 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6285 
    result.write(oprot)
6286 
    oprot.writeMessageEnd()
6287 
    oprot.trans.flush()
6288 
 
4247 rajveer 6289 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6290 
    args = markOrderCancellationRequestReceived_args()
6291 
    args.read(iprot)
6292 
    iprot.readMessageEnd()
6293 
    result = markOrderCancellationRequestReceived_result()
6294 
    try:
6295 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6296 
    except TransactionServiceException, ex:
6297 
      result.ex = ex
6298 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6299 
    result.write(oprot)
6300 
    oprot.writeMessageEnd()
6301 
    oprot.trans.flush()
4018 chandransh 6302 
 
4247 rajveer 6303 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6304 
    args = markOrderCancellationRequestConfirmed_args()
6305 
    args.read(iprot)
6306 
    iprot.readMessageEnd()
6307 
    result = markOrderCancellationRequestConfirmed_result()
6308 
    try:
6309 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6310 
    except TransactionServiceException, ex:
6311 
      result.ex = ex
6312 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6313 
    result.write(oprot)
6314 
    oprot.writeMessageEnd()
6315 
    oprot.trans.flush()
6316 
 
6317 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6318 
    args = markOrderCancellationRequestDenied_args()
6319 
    args.read(iprot)
6320 
    iprot.readMessageEnd()
6321 
    result = markOrderCancellationRequestDenied_result()
6322 
    try:
6323 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6324 
    except TransactionServiceException, ex:
6325 
      result.ex = ex
6326 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6327 
    result.write(oprot)
6328 
    oprot.writeMessageEnd()
6329 
    oprot.trans.flush()
6330 
 
4258 rajveer 6331 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6332 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6333 
    args.read(iprot)
6334 
    iprot.readMessageEnd()
4258 rajveer 6335 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6336 
    try:
4258 rajveer 6337 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6338 
    except TransactionServiceException, ex:
6339 
      result.ex = ex
4258 rajveer 6340 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6341 
    result.write(oprot)
6342 
    oprot.writeMessageEnd()
6343 
    oprot.trans.flush()
6344 
 
4259 anupam.sin 6345 
  def process_refundTransaction(self, seqid, iprot, oprot):
6346 
    args = refundTransaction_args()
6347 
    args.read(iprot)
6348 
    iprot.readMessageEnd()
6349 
    result = refundTransaction_result()
6350 
    try:
6351 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6352 
    except TransactionServiceException, ex:
6353 
      result.ex = ex
6354 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
4247 rajveer 6358 
 
4324 mandeep.dh 6359 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6360 
    args = updateShipmentAddress_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = updateShipmentAddress_result()
6364 
    try:
6365 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6366 
    except TransactionServiceException, ex:
6367 
      result.ex = ex
6368 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6369 
    result.write(oprot)
6370 
    oprot.writeMessageEnd()
6371 
    oprot.trans.flush()
6372 
 
4285 rajveer 6373 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6374 
    args = acceptOrdersForItemId_args()
6375 
    args.read(iprot)
6376 
    iprot.readMessageEnd()
6377 
    result = acceptOrdersForItemId_result()
6378 
    try:
6379 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6380 
    except TransactionServiceException, ex:
6381 
      result.ex = ex
6382 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
4259 anupam.sin 6386 
 
4303 rajveer 6387 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6388 
    args = markOrdersAsPORaised_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = markOrdersAsPORaised_result()
6392 
    try:
4369 rajveer 6393 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6394 
    except TransactionServiceException, ex:
6395 
      result.ex = ex
6396 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
4285 rajveer 6400 
 
4303 rajveer 6401 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6402 
    args = markOrdersAsReversalInitiated_args()
6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
6405 
    result = markOrdersAsReversalInitiated_result()
6406 
    try:
4369 rajveer 6407 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6408 
    except TransactionServiceException, ex:
6409 
      result.ex = ex
6410 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
6414 
 
6415 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6416 
    args = markOrdersAsNotAvailabke_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = markOrdersAsNotAvailabke_result()
6420 
    try:
4369 rajveer 6421 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6422 
    except TransactionServiceException, ex:
6423 
      result.ex = ex
6424 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6425 
    result.write(oprot)
6426 
    oprot.writeMessageEnd()
6427 
    oprot.trans.flush()
6428 
 
4369 rajveer 6429 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6430 
    args = markOrdersAsTimeout_args()
6431 
    args.read(iprot)
6432 
    iprot.readMessageEnd()
6433 
    result = markOrdersAsTimeout_result()
6434 
    try:
6435 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6436 
    except TransactionServiceException, ex:
6437 
      result.ex = ex
6438 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
4303 rajveer 6442 
 
4662 rajveer 6443 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6444 
    args = markOrderAsLostInTransit_args()
6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
6447 
    result = markOrderAsLostInTransit_result()
6448 
    try:
6449 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6450 
    except TransactionServiceException, ex:
6451 
      result.ex = ex
6452 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6453 
    result.write(oprot)
6454 
    oprot.writeMessageEnd()
6455 
    oprot.trans.flush()
6456 
 
4386 anupam.sin 6457 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6458 
    args = getOrderForAwb_args()
6459 
    args.read(iprot)
6460 
    iprot.readMessageEnd()
6461 
    result = getOrderForAwb_result()
6462 
    try:
6463 
      result.success = self._handler.getOrderForAwb(args.awb)
6464 
    except TransactionServiceException, ex:
6465 
      result.ex = ex
6466 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6467 
    result.write(oprot)
6468 
    oprot.writeMessageEnd()
6469 
    oprot.trans.flush()
4369 rajveer 6470 
 
4506 phani.kuma 6471 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6472 
    args = getOrdersForProviderForStatus_args()
6473 
    args.read(iprot)
6474 
    iprot.readMessageEnd()
6475 
    result = getOrdersForProviderForStatus_result()
6476 
    try:
4910 phani.kuma 6477 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6478 
    except TransactionServiceException, ex:
6479 
      result.ex = ex
6480 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
4386 anupam.sin 6484 
 
4600 varun.gupt 6485 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6486 
    args = getBilledOrdersForVendor_args()
6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
6489 
    result = getBilledOrdersForVendor_result()
6490 
    try:
6491 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6492 
    except TransactionServiceException, ex:
6493 
      result.ex = ex
6494 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
4506 phani.kuma 6498 
 
4607 rajveer 6499 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6500 
    args = getSlippedSippingDateOrders_args()
6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
6503 
    result = getSlippedSippingDateOrders_result()
6504 
    try:
6505 
      result.success = self._handler.getSlippedSippingDateOrders()
6506 
    except TransactionServiceException, ex:
6507 
      result.ex = ex
6508 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6509 
    result.write(oprot)
6510 
    oprot.writeMessageEnd()
6511 
    oprot.trans.flush()
6512 
 
4709 rajveer 6513 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6514 
    args = getCancelledOrders_args()
6515 
    args.read(iprot)
6516 
    iprot.readMessageEnd()
6517 
    result = getCancelledOrders_result()
6518 
    try:
6519 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6520 
    except TransactionServiceException, ex:
6521 
      result.ex = ex
6522 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6523 
    result.write(oprot)
6524 
    oprot.writeMessageEnd()
6525 
    oprot.trans.flush()
6526 
 
4600 varun.gupt 6527 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6528 
    args = saveBluedartSettlements_args()
6529 
    args.read(iprot)
6530 
    iprot.readMessageEnd()
6531 
    result = saveBluedartSettlements_result()
6532 
    try:
6533 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6534 
    except TransactionServiceException, ex:
6535 
      result.ex = ex
6536 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6537 
    result.write(oprot)
6538 
    oprot.writeMessageEnd()
6539 
    oprot.trans.flush()
6540 
 
6541 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6542 
    args = savePaymentSettlements_args()
6543 
    args.read(iprot)
6544 
    iprot.readMessageEnd()
6545 
    result = savePaymentSettlements_result()
6546 
    try:
4905 varun.gupt 6547 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6548 
    except TransactionServiceException, ex:
6549 
      result.ex = ex
6550 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6551 
    result.write(oprot)
6552 
    oprot.writeMessageEnd()
6553 
    oprot.trans.flush()
6554 
 
6555 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6556 
    args = saveEBSSettlementSummary_args()
6557 
    args.read(iprot)
6558 
    iprot.readMessageEnd()
6559 
    result = saveEBSSettlementSummary_result()
6560 
    try:
6561 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6562 
    except TransactionServiceException, ex:
6563 
      result.ex = ex
6564 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6565 
    result.write(oprot)
6566 
    oprot.writeMessageEnd()
6567 
    oprot.trans.flush()
6568 
 
5386 phani.kuma 6569 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6570 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6571 
    args.read(iprot)
6572 
    iprot.readMessageEnd()
5386 phani.kuma 6573 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6574 
    try:
5386 phani.kuma 6575 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6576 
    except TransactionServiceException, ex:
6577 
      result.ex = ex
5386 phani.kuma 6578 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6579 
    result.write(oprot)
6580 
    oprot.writeMessageEnd()
6581 
    oprot.trans.flush()
6582 
 
5386 phani.kuma 6583 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6584 
    args = getSettlementForCod_args()
6585 
    args.read(iprot)
6586 
    iprot.readMessageEnd()
6587 
    result = getSettlementForCod_result()
6588 
    try:
6589 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6590 
    except TransactionServiceException, ex:
6591 
      result.ex = ex
6592 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6593 
    result.write(oprot)
6594 
    oprot.writeMessageEnd()
6595 
    oprot.trans.flush()
6596 
 
4600 varun.gupt 6597 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6598 
    args = getEBSSettlementSummaries_args()
6599 
    args.read(iprot)
6600 
    iprot.readMessageEnd()
6601 
    result = getEBSSettlementSummaries_result()
6602 
    try:
6603 
      result.success = self._handler.getEBSSettlementSummaries()
6604 
    except TransactionServiceException, ex:
6605 
      result.ex = ex
6606 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6607 
    result.write(oprot)
6608 
    oprot.writeMessageEnd()
6609 
    oprot.trans.flush()
6610 
 
6611 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6612 
    args = markEBSSettlementUploaded_args()
6613 
    args.read(iprot)
6614 
    iprot.readMessageEnd()
6615 
    result = markEBSSettlementUploaded_result()
6616 
    try:
6617 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6618 
    except TransactionServiceException, ex:
6619 
      result.ex = ex
6620 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6621 
    result.write(oprot)
6622 
    oprot.writeMessageEnd()
6623 
    oprot.trans.flush()
6624 
 
6625 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6626 
    args = getEBSSettlementDate_args()
6627 
    args.read(iprot)
6628 
    iprot.readMessageEnd()
6629 
    result = getEBSSettlementDate_result()
6630 
    try:
6631 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6632 
    except TransactionServiceException, ex:
6633 
      result.ex = ex
6634 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6635 
    result.write(oprot)
6636 
    oprot.writeMessageEnd()
6637 
    oprot.trans.flush()
6638 
 
4715 varun.gupt 6639 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6640 
    args = getSettlementsByDate_args()
6641 
    args.read(iprot)
6642 
    iprot.readMessageEnd()
6643 
    result = getSettlementsByDate_result()
6644 
    try:
6645 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6646 
    except TransactionServiceException, ex:
6647 
      result.ex = ex
6648 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6649 
    result.write(oprot)
6650 
    oprot.writeMessageEnd()
6651 
    oprot.trans.flush()
4600 varun.gupt 6652 
 
4715 varun.gupt 6653 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6654 
    args = getReshippedOrderIds_args()
6655 
    args.read(iprot)
6656 
    iprot.readMessageEnd()
6657 
    result = getReshippedOrderIds_result()
6658 
    try:
6659 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6660 
    except TransactionServiceException, ex:
6661 
      result.ex = ex
6662 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6663 
    result.write(oprot)
6664 
    oprot.writeMessageEnd()
6665 
    oprot.trans.flush()
6666 
 
4875 varun.gupt 6667 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6668 
    args = getOrdersWhereVendorNotPaid_args()
6669 
    args.read(iprot)
6670 
    iprot.readMessageEnd()
6671 
    result = getOrdersWhereVendorNotPaid_result()
6672 
    try:
6673 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6674 
    except TransactionServiceException, ex:
6675 
      result.ex = ex
6676 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6677 
    result.write(oprot)
6678 
    oprot.writeMessageEnd()
6679 
    oprot.trans.flush()
4757 mandeep.dh 6680 
 
5031 varun.gupt 6681 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6682 
    args = getStatusDistributionOfOrders_args()
6683 
    args.read(iprot)
6684 
    iprot.readMessageEnd()
6685 
    result = getStatusDistributionOfOrders_result()
6686 
    try:
6687 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6688 
    except TransactionServiceException, ex:
6689 
      result.ex = ex
6690 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6691 
    result.write(oprot)
6692 
    oprot.writeMessageEnd()
6693 
    oprot.trans.flush()
4875 varun.gupt 6694 
 
5067 varun.gupt 6695 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6696 
    args = getOrderIdsForStatus_args()
6697 
    args.read(iprot)
6698 
    iprot.readMessageEnd()
6699 
    result = getOrderIdsForStatus_result()
6700 
    try:
6701 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6702 
    except TransactionServiceException, ex:
6703 
      result.ex = ex
6704 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6705 
    result.write(oprot)
6706 
    oprot.writeMessageEnd()
6707 
    oprot.trans.flush()
5031 varun.gupt 6708 
 
5348 anupam.sin 6709 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6710 
    args = updateCODAgent_args()
6711 
    args.read(iprot)
6712 
    iprot.readMessageEnd()
6713 
    result = updateCODAgent_result()
6714 
    try:
6715 
      self._handler.updateCODAgent(args.agent, args.orderId)
6716 
    except TransactionServiceException, ex:
6717 
      result.ex = ex
6718 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6719 
    result.write(oprot)
6720 
    oprot.writeMessageEnd()
6721 
    oprot.trans.flush()
6722 
 
5099 varun.gupt 6723 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6724 
    args = updateOrderAsPaidToVendor_args()
6725 
    args.read(iprot)
6726 
    iprot.readMessageEnd()
6727 
    result = updateOrderAsPaidToVendor_result()
6728 
    try:
6729 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6730 
    except TransactionServiceException, ex:
6731 
      result.ex = ex
6732 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6733 
    result.write(oprot)
6734 
    oprot.writeMessageEnd()
6735 
    oprot.trans.flush()
5067 varun.gupt 6736 
 
5386 phani.kuma 6737 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
6738 
    args = updateOrderOnlyAsPaidToVendor_args()
6739 
    args.read(iprot)
6740 
    iprot.readMessageEnd()
6741 
    result = updateOrderOnlyAsPaidToVendor_result()
6742 
    try:
6743 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
6744 
    except TransactionServiceException, ex:
6745 
      result.ex = ex
6746 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
6747 
    result.write(oprot)
6748 
    oprot.writeMessageEnd()
6749 
    oprot.trans.flush()
6750 
 
5208 varun.gupt 6751 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6752 
    args = getRefundedOrdersMarkedPaid_args()
6753 
    args.read(iprot)
6754 
    iprot.readMessageEnd()
6755 
    result = getRefundedOrdersMarkedPaid_result()
6756 
    try:
6757 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6758 
    except TransactionServiceException, ex:
6759 
      result.ex = ex
6760 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6761 
    result.write(oprot)
6762 
    oprot.writeMessageEnd()
6763 
    oprot.trans.flush()
5099 varun.gupt 6764 
 
5208 varun.gupt 6765 
 
94 ashish 6766 
# HELPER FUNCTIONS AND STRUCTURES
6767 
 
6768 
class createTransaction_args:
6769 
  """
6770 
  Attributes:
6771 
   - transaction
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    None, # 0
6776 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6777 
  )
6778 
 
6779 
  def __init__(self, transaction=None,):
6780 
    self.transaction = transaction
6781 
 
6782 
  def read(self, iprot):
6783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6785 
      return
6786 
    iprot.readStructBegin()
6787 
    while True:
6788 
      (fname, ftype, fid) = iprot.readFieldBegin()
6789 
      if ftype == TType.STOP:
6790 
        break
6791 
      if fid == 1:
6792 
        if ftype == TType.STRUCT:
6793 
          self.transaction = Transaction()
6794 
          self.transaction.read(iprot)
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
6806 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6807 
    if self.transaction is not None:
94 ashish 6808 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6809 
      self.transaction.write(oprot)
6810 
      oprot.writeFieldEnd()
6811 
    oprot.writeFieldStop()
6812 
    oprot.writeStructEnd()
6813 
 
3431 rajveer 6814 
  def validate(self):
6815 
    return
6816 
 
6817 
 
94 ashish 6818 
  def __repr__(self):
6819 
    L = ['%s=%r' % (key, value)
6820 
      for key, value in self.__dict__.iteritems()]
6821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6822 
 
6823 
  def __eq__(self, other):
6824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6825 
 
6826 
  def __ne__(self, other):
6827 
    return not (self == other)
6828 
 
6829 
class createTransaction_result:
6830 
  """
6831 
  Attributes:
132 ashish 6832 
   - success
94 ashish 6833 
   - ex
6834 
  """
6835 
 
6836 
  thrift_spec = (
132 ashish 6837 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6838 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6839 
  )
6840 
 
132 ashish 6841 
  def __init__(self, success=None, ex=None,):
6842 
    self.success = success
94 ashish 6843 
    self.ex = ex
6844 
 
6845 
  def read(self, iprot):
6846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6848 
      return
6849 
    iprot.readStructBegin()
6850 
    while True:
6851 
      (fname, ftype, fid) = iprot.readFieldBegin()
6852 
      if ftype == TType.STOP:
6853 
        break
132 ashish 6854 
      if fid == 0:
6855 
        if ftype == TType.I64:
6856 
          self.success = iprot.readI64();
6857 
        else:
6858 
          iprot.skip(ftype)
6859 
      elif fid == 1:
94 ashish 6860 
        if ftype == TType.STRUCT:
6861 
          self.ex = TransactionServiceException()
6862 
          self.ex.read(iprot)
6863 
        else:
6864 
          iprot.skip(ftype)
6865 
      else:
6866 
        iprot.skip(ftype)
6867 
      iprot.readFieldEnd()
6868 
    iprot.readStructEnd()
6869 
 
6870 
  def write(self, oprot):
6871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6873 
      return
6874 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6875 
    if self.success is not None:
132 ashish 6876 
      oprot.writeFieldBegin('success', TType.I64, 0)
6877 
      oprot.writeI64(self.success)
6878 
      oprot.writeFieldEnd()
3431 rajveer 6879 
    if self.ex is not None:
94 ashish 6880 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6881 
      self.ex.write(oprot)
6882 
      oprot.writeFieldEnd()
6883 
    oprot.writeFieldStop()
6884 
    oprot.writeStructEnd()
6885 
 
3431 rajveer 6886 
  def validate(self):
6887 
    return
6888 
 
6889 
 
94 ashish 6890 
  def __repr__(self):
6891 
    L = ['%s=%r' % (key, value)
6892 
      for key, value in self.__dict__.iteritems()]
6893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6894 
 
6895 
  def __eq__(self, other):
6896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6897 
 
6898 
  def __ne__(self, other):
6899 
    return not (self == other)
6900 
 
6901 
class getTransaction_args:
6902 
  """
6903 
  Attributes:
6904 
   - id
6905 
  """
6906 
 
6907 
  thrift_spec = (
6908 
    None, # 0
6909 
    (1, TType.I64, 'id', None, None, ), # 1
6910 
  )
6911 
 
6912 
  def __init__(self, id=None,):
6913 
    self.id = id
6914 
 
6915 
  def read(self, iprot):
6916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6918 
      return
6919 
    iprot.readStructBegin()
6920 
    while True:
6921 
      (fname, ftype, fid) = iprot.readFieldBegin()
6922 
      if ftype == TType.STOP:
6923 
        break
6924 
      if fid == 1:
6925 
        if ftype == TType.I64:
6926 
          self.id = iprot.readI64();
6927 
        else:
6928 
          iprot.skip(ftype)
6929 
      else:
6930 
        iprot.skip(ftype)
6931 
      iprot.readFieldEnd()
6932 
    iprot.readStructEnd()
6933 
 
6934 
  def write(self, oprot):
6935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6937 
      return
6938 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6939 
    if self.id is not None:
94 ashish 6940 
      oprot.writeFieldBegin('id', TType.I64, 1)
6941 
      oprot.writeI64(self.id)
6942 
      oprot.writeFieldEnd()
6943 
    oprot.writeFieldStop()
6944 
    oprot.writeStructEnd()
6945 
 
3431 rajveer 6946 
  def validate(self):
6947 
    return
6948 
 
6949 
 
94 ashish 6950 
  def __repr__(self):
6951 
    L = ['%s=%r' % (key, value)
6952 
      for key, value in self.__dict__.iteritems()]
6953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6954 
 
6955 
  def __eq__(self, other):
6956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6957 
 
6958 
  def __ne__(self, other):
6959 
    return not (self == other)
6960 
 
6961 
class getTransaction_result:
6962 
  """
6963 
  Attributes:
6964 
   - success
6965 
   - ex
6966 
  """
6967 
 
6968 
  thrift_spec = (
6969 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6971 
  )
6972 
 
6973 
  def __init__(self, success=None, ex=None,):
6974 
    self.success = success
6975 
    self.ex = ex
6976 
 
6977 
  def read(self, iprot):
6978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6980 
      return
6981 
    iprot.readStructBegin()
6982 
    while True:
6983 
      (fname, ftype, fid) = iprot.readFieldBegin()
6984 
      if ftype == TType.STOP:
6985 
        break
6986 
      if fid == 0:
6987 
        if ftype == TType.STRUCT:
6988 
          self.success = Transaction()
6989 
          self.success.read(iprot)
6990 
        else:
6991 
          iprot.skip(ftype)
6992 
      elif fid == 1:
6993 
        if ftype == TType.STRUCT:
6994 
          self.ex = TransactionServiceException()
6995 
          self.ex.read(iprot)
6996 
        else:
6997 
          iprot.skip(ftype)
6998 
      else:
6999 
        iprot.skip(ftype)
7000 
      iprot.readFieldEnd()
7001 
    iprot.readStructEnd()
7002 
 
7003 
  def write(self, oprot):
7004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7006 
      return
7007 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7008 
    if self.success is not None:
94 ashish 7009 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7010 
      self.success.write(oprot)
7011 
      oprot.writeFieldEnd()
3431 rajveer 7012 
    if self.ex is not None:
94 ashish 7013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7014 
      self.ex.write(oprot)
7015 
      oprot.writeFieldEnd()
7016 
    oprot.writeFieldStop()
7017 
    oprot.writeStructEnd()
7018 
 
3431 rajveer 7019 
  def validate(self):
7020 
    return
7021 
 
7022 
 
94 ashish 7023 
  def __repr__(self):
7024 
    L = ['%s=%r' % (key, value)
7025 
      for key, value in self.__dict__.iteritems()]
7026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7027 
 
7028 
  def __eq__(self, other):
7029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7030 
 
7031 
  def __ne__(self, other):
7032 
    return not (self == other)
7033 
 
7034 
class getTransactionsForCustomer_args:
7035 
  """
7036 
  Attributes:
7037 
   - customerId
7038 
   - from_date
7039 
   - to_date
7040 
   - status
7041 
  """
7042 
 
7043 
  thrift_spec = (
7044 
    None, # 0
7045 
    (1, TType.I64, 'customerId', None, None, ), # 1
7046 
    (2, TType.I64, 'from_date', None, None, ), # 2
7047 
    (3, TType.I64, 'to_date', None, None, ), # 3
7048 
    (4, TType.I32, 'status', None, None, ), # 4
7049 
  )
7050 
 
7051 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7052 
    self.customerId = customerId
7053 
    self.from_date = from_date
7054 
    self.to_date = to_date
7055 
    self.status = status
7056 
 
7057 
  def read(self, iprot):
7058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7060 
      return
7061 
    iprot.readStructBegin()
7062 
    while True:
7063 
      (fname, ftype, fid) = iprot.readFieldBegin()
7064 
      if ftype == TType.STOP:
7065 
        break
7066 
      if fid == 1:
7067 
        if ftype == TType.I64:
7068 
          self.customerId = iprot.readI64();
7069 
        else:
7070 
          iprot.skip(ftype)
7071 
      elif fid == 2:
7072 
        if ftype == TType.I64:
7073 
          self.from_date = iprot.readI64();
7074 
        else:
7075 
          iprot.skip(ftype)
7076 
      elif fid == 3:
7077 
        if ftype == TType.I64:
7078 
          self.to_date = iprot.readI64();
7079 
        else:
7080 
          iprot.skip(ftype)
7081 
      elif fid == 4:
7082 
        if ftype == TType.I32:
7083 
          self.status = iprot.readI32();
7084 
        else:
7085 
          iprot.skip(ftype)
7086 
      else:
7087 
        iprot.skip(ftype)
7088 
      iprot.readFieldEnd()
7089 
    iprot.readStructEnd()
7090 
 
7091 
  def write(self, oprot):
7092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7094 
      return
7095 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7096 
    if self.customerId is not None:
94 ashish 7097 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7098 
      oprot.writeI64(self.customerId)
7099 
      oprot.writeFieldEnd()
3431 rajveer 7100 
    if self.from_date is not None:
94 ashish 7101 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7102 
      oprot.writeI64(self.from_date)
7103 
      oprot.writeFieldEnd()
3431 rajveer 7104 
    if self.to_date is not None:
94 ashish 7105 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7106 
      oprot.writeI64(self.to_date)
7107 
      oprot.writeFieldEnd()
3431 rajveer 7108 
    if self.status is not None:
94 ashish 7109 
      oprot.writeFieldBegin('status', TType.I32, 4)
7110 
      oprot.writeI32(self.status)
7111 
      oprot.writeFieldEnd()
7112 
    oprot.writeFieldStop()
7113 
    oprot.writeStructEnd()
7114 
 
3431 rajveer 7115 
  def validate(self):
7116 
    return
7117 
 
7118 
 
94 ashish 7119 
  def __repr__(self):
7120 
    L = ['%s=%r' % (key, value)
7121 
      for key, value in self.__dict__.iteritems()]
7122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7123 
 
7124 
  def __eq__(self, other):
7125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7126 
 
7127 
  def __ne__(self, other):
7128 
    return not (self == other)
7129 
 
7130 
class getTransactionsForCustomer_result:
7131 
  """
7132 
  Attributes:
7133 
   - success
7134 
   - ex
7135 
  """
7136 
 
7137 
  thrift_spec = (
7138 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7140 
  )
7141 
 
7142 
  def __init__(self, success=None, ex=None,):
7143 
    self.success = success
7144 
    self.ex = ex
7145 
 
7146 
  def read(self, iprot):
7147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7149 
      return
7150 
    iprot.readStructBegin()
7151 
    while True:
7152 
      (fname, ftype, fid) = iprot.readFieldBegin()
7153 
      if ftype == TType.STOP:
7154 
        break
7155 
      if fid == 0:
7156 
        if ftype == TType.LIST:
7157 
          self.success = []
5031 varun.gupt 7158 
          (_etype66, _size63) = iprot.readListBegin()
7159 
          for _i67 in xrange(_size63):
7160 
            _elem68 = Transaction()
7161 
            _elem68.read(iprot)
7162 
            self.success.append(_elem68)
94 ashish 7163 
          iprot.readListEnd()
7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      elif fid == 1:
7167 
        if ftype == TType.STRUCT:
7168 
          self.ex = TransactionServiceException()
7169 
          self.ex.read(iprot)
7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      else:
7173 
        iprot.skip(ftype)
7174 
      iprot.readFieldEnd()
7175 
    iprot.readStructEnd()
7176 
 
7177 
  def write(self, oprot):
7178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7180 
      return
7181 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7182 
    if self.success is not None:
94 ashish 7183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7185 
      for iter69 in self.success:
7186 
        iter69.write(oprot)
94 ashish 7187 
      oprot.writeListEnd()
7188 
      oprot.writeFieldEnd()
3431 rajveer 7189 
    if self.ex is not None:
94 ashish 7190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7191 
      self.ex.write(oprot)
7192 
      oprot.writeFieldEnd()
7193 
    oprot.writeFieldStop()
7194 
    oprot.writeStructEnd()
7195 
 
3431 rajveer 7196 
  def validate(self):
7197 
    return
7198 
 
7199 
 
94 ashish 7200 
  def __repr__(self):
7201 
    L = ['%s=%r' % (key, value)
7202 
      for key, value in self.__dict__.iteritems()]
7203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7204 
 
7205 
  def __eq__(self, other):
7206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7207 
 
7208 
  def __ne__(self, other):
7209 
    return not (self == other)
7210 
 
132 ashish 7211 
class getTransactionsForShoppingCartId_args:
7212 
  """
7213 
  Attributes:
7214 
   - shoppingCartId
7215 
  """
7216 
 
7217 
  thrift_spec = (
7218 
    None, # 0
7219 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7220 
  )
7221 
 
7222 
  def __init__(self, shoppingCartId=None,):
7223 
    self.shoppingCartId = shoppingCartId
7224 
 
7225 
  def read(self, iprot):
7226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7228 
      return
7229 
    iprot.readStructBegin()
7230 
    while True:
7231 
      (fname, ftype, fid) = iprot.readFieldBegin()
7232 
      if ftype == TType.STOP:
7233 
        break
7234 
      if fid == 1:
7235 
        if ftype == TType.I64:
7236 
          self.shoppingCartId = iprot.readI64();
7237 
        else:
7238 
          iprot.skip(ftype)
7239 
      else:
7240 
        iprot.skip(ftype)
7241 
      iprot.readFieldEnd()
7242 
    iprot.readStructEnd()
7243 
 
7244 
  def write(self, oprot):
7245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7247 
      return
7248 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7249 
    if self.shoppingCartId is not None:
132 ashish 7250 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7251 
      oprot.writeI64(self.shoppingCartId)
7252 
      oprot.writeFieldEnd()
7253 
    oprot.writeFieldStop()
7254 
    oprot.writeStructEnd()
7255 
 
3431 rajveer 7256 
  def validate(self):
7257 
    return
7258 
 
7259 
 
132 ashish 7260 
  def __repr__(self):
7261 
    L = ['%s=%r' % (key, value)
7262 
      for key, value in self.__dict__.iteritems()]
7263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7264 
 
7265 
  def __eq__(self, other):
7266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7267 
 
7268 
  def __ne__(self, other):
7269 
    return not (self == other)
7270 
 
7271 
class getTransactionsForShoppingCartId_result:
7272 
  """
7273 
  Attributes:
7274 
   - success
7275 
   - ex
7276 
  """
7277 
 
7278 
  thrift_spec = (
7279 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7281 
  )
7282 
 
7283 
  def __init__(self, success=None, ex=None,):
7284 
    self.success = success
7285 
    self.ex = ex
7286 
 
7287 
  def read(self, iprot):
7288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7290 
      return
7291 
    iprot.readStructBegin()
7292 
    while True:
7293 
      (fname, ftype, fid) = iprot.readFieldBegin()
7294 
      if ftype == TType.STOP:
7295 
        break
7296 
      if fid == 0:
7297 
        if ftype == TType.LIST:
7298 
          self.success = []
5031 varun.gupt 7299 
          (_etype73, _size70) = iprot.readListBegin()
7300 
          for _i74 in xrange(_size70):
7301 
            _elem75 = Transaction()
7302 
            _elem75.read(iprot)
7303 
            self.success.append(_elem75)
132 ashish 7304 
          iprot.readListEnd()
7305 
        else:
7306 
          iprot.skip(ftype)
7307 
      elif fid == 1:
7308 
        if ftype == TType.STRUCT:
7309 
          self.ex = TransactionServiceException()
7310 
          self.ex.read(iprot)
7311 
        else:
7312 
          iprot.skip(ftype)
7313 
      else:
7314 
        iprot.skip(ftype)
7315 
      iprot.readFieldEnd()
7316 
    iprot.readStructEnd()
7317 
 
7318 
  def write(self, oprot):
7319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7321 
      return
7322 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7323 
    if self.success is not None:
132 ashish 7324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7326 
      for iter76 in self.success:
7327 
        iter76.write(oprot)
132 ashish 7328 
      oprot.writeListEnd()
7329 
      oprot.writeFieldEnd()
3431 rajveer 7330 
    if self.ex is not None:
132 ashish 7331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7332 
      self.ex.write(oprot)
7333 
      oprot.writeFieldEnd()
7334 
    oprot.writeFieldStop()
7335 
    oprot.writeStructEnd()
7336 
 
3431 rajveer 7337 
  def validate(self):
7338 
    return
7339 
 
7340 
 
132 ashish 7341 
  def __repr__(self):
7342 
    L = ['%s=%r' % (key, value)
7343 
      for key, value in self.__dict__.iteritems()]
7344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7345 
 
7346 
  def __eq__(self, other):
7347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7348 
 
7349 
  def __ne__(self, other):
7350 
    return not (self == other)
7351 
 
94 ashish 7352 
class getTransactionStatus_args:
7353 
  """
7354 
  Attributes:
7355 
   - transactionId
7356 
  """
7357 
 
7358 
  thrift_spec = (
7359 
    None, # 0
7360 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7361 
  )
7362 
 
7363 
  def __init__(self, transactionId=None,):
7364 
    self.transactionId = transactionId
7365 
 
7366 
  def read(self, iprot):
7367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7369 
      return
7370 
    iprot.readStructBegin()
7371 
    while True:
7372 
      (fname, ftype, fid) = iprot.readFieldBegin()
7373 
      if ftype == TType.STOP:
7374 
        break
7375 
      if fid == 1:
7376 
        if ftype == TType.I64:
7377 
          self.transactionId = iprot.readI64();
7378 
        else:
7379 
          iprot.skip(ftype)
7380 
      else:
7381 
        iprot.skip(ftype)
7382 
      iprot.readFieldEnd()
7383 
    iprot.readStructEnd()
7384 
 
7385 
  def write(self, oprot):
7386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7388 
      return
7389 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7390 
    if self.transactionId is not None:
94 ashish 7391 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7392 
      oprot.writeI64(self.transactionId)
7393 
      oprot.writeFieldEnd()
7394 
    oprot.writeFieldStop()
7395 
    oprot.writeStructEnd()
7396 
 
3431 rajveer 7397 
  def validate(self):
7398 
    return
7399 
 
7400 
 
94 ashish 7401 
  def __repr__(self):
7402 
    L = ['%s=%r' % (key, value)
7403 
      for key, value in self.__dict__.iteritems()]
7404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7405 
 
7406 
  def __eq__(self, other):
7407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7408 
 
7409 
  def __ne__(self, other):
7410 
    return not (self == other)
7411 
 
7412 
class getTransactionStatus_result:
7413 
  """
7414 
  Attributes:
7415 
   - success
7416 
   - ex
7417 
  """
7418 
 
7419 
  thrift_spec = (
7420 
    (0, TType.I32, 'success', None, None, ), # 0
7421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7422 
  )
7423 
 
7424 
  def __init__(self, success=None, ex=None,):
7425 
    self.success = success
7426 
    self.ex = ex
7427 
 
7428 
  def read(self, iprot):
7429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7431 
      return
7432 
    iprot.readStructBegin()
7433 
    while True:
7434 
      (fname, ftype, fid) = iprot.readFieldBegin()
7435 
      if ftype == TType.STOP:
7436 
        break
7437 
      if fid == 0:
7438 
        if ftype == TType.I32:
7439 
          self.success = iprot.readI32();
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      elif fid == 1:
7443 
        if ftype == TType.STRUCT:
7444 
          self.ex = TransactionServiceException()
7445 
          self.ex.read(iprot)
7446 
        else:
7447 
          iprot.skip(ftype)
7448 
      else:
7449 
        iprot.skip(ftype)
7450 
      iprot.readFieldEnd()
7451 
    iprot.readStructEnd()
7452 
 
7453 
  def write(self, oprot):
7454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7456 
      return
7457 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7458 
    if self.success is not None:
94 ashish 7459 
      oprot.writeFieldBegin('success', TType.I32, 0)
7460 
      oprot.writeI32(self.success)
7461 
      oprot.writeFieldEnd()
3431 rajveer 7462 
    if self.ex is not None:
94 ashish 7463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7464 
      self.ex.write(oprot)
7465 
      oprot.writeFieldEnd()
7466 
    oprot.writeFieldStop()
7467 
    oprot.writeStructEnd()
7468 
 
3431 rajveer 7469 
  def validate(self):
7470 
    return
7471 
 
7472 
 
94 ashish 7473 
  def __repr__(self):
7474 
    L = ['%s=%r' % (key, value)
7475 
      for key, value in self.__dict__.iteritems()]
7476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7477 
 
7478 
  def __eq__(self, other):
7479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7480 
 
7481 
  def __ne__(self, other):
7482 
    return not (self == other)
7483 
 
7484 
class changeTransactionStatus_args:
7485 
  """
7486 
  Attributes:
7487 
   - transactionId
7488 
   - status
7489 
   - description
7490 
  """
7491 
 
7492 
  thrift_spec = (
7493 
    None, # 0
7494 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7495 
    (2, TType.I32, 'status', None, None, ), # 2
7496 
    (3, TType.STRING, 'description', None, None, ), # 3
7497 
  )
7498 
 
7499 
  def __init__(self, transactionId=None, status=None, description=None,):
7500 
    self.transactionId = transactionId
7501 
    self.status = status
7502 
    self.description = description
7503 
 
7504 
  def read(self, iprot):
7505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7507 
      return
7508 
    iprot.readStructBegin()
7509 
    while True:
7510 
      (fname, ftype, fid) = iprot.readFieldBegin()
7511 
      if ftype == TType.STOP:
7512 
        break
7513 
      if fid == 1:
7514 
        if ftype == TType.I64:
7515 
          self.transactionId = iprot.readI64();
7516 
        else:
7517 
          iprot.skip(ftype)
7518 
      elif fid == 2:
7519 
        if ftype == TType.I32:
7520 
          self.status = iprot.readI32();
7521 
        else:
7522 
          iprot.skip(ftype)
7523 
      elif fid == 3:
7524 
        if ftype == TType.STRING:
7525 
          self.description = iprot.readString();
7526 
        else:
7527 
          iprot.skip(ftype)
7528 
      else:
7529 
        iprot.skip(ftype)
7530 
      iprot.readFieldEnd()
7531 
    iprot.readStructEnd()
7532 
 
7533 
  def write(self, oprot):
7534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7536 
      return
7537 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7538 
    if self.transactionId is not None:
94 ashish 7539 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7540 
      oprot.writeI64(self.transactionId)
7541 
      oprot.writeFieldEnd()
3431 rajveer 7542 
    if self.status is not None:
94 ashish 7543 
      oprot.writeFieldBegin('status', TType.I32, 2)
7544 
      oprot.writeI32(self.status)
7545 
      oprot.writeFieldEnd()
3431 rajveer 7546 
    if self.description is not None:
94 ashish 7547 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7548 
      oprot.writeString(self.description)
7549 
      oprot.writeFieldEnd()
7550 
    oprot.writeFieldStop()
7551 
    oprot.writeStructEnd()
7552 
 
3431 rajveer 7553 
  def validate(self):
7554 
    return
7555 
 
7556 
 
94 ashish 7557 
  def __repr__(self):
7558 
    L = ['%s=%r' % (key, value)
7559 
      for key, value in self.__dict__.iteritems()]
7560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7561 
 
7562 
  def __eq__(self, other):
7563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7564 
 
7565 
  def __ne__(self, other):
7566 
    return not (self == other)
7567 
 
7568 
class changeTransactionStatus_result:
7569 
  """
7570 
  Attributes:
7571 
   - success
7572 
   - ex
7573 
  """
7574 
 
7575 
  thrift_spec = (
7576 
    (0, TType.BOOL, 'success', None, None, ), # 0
7577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7578 
  )
7579 
 
7580 
  def __init__(self, success=None, ex=None,):
7581 
    self.success = success
7582 
    self.ex = ex
7583 
 
7584 
  def read(self, iprot):
7585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7587 
      return
7588 
    iprot.readStructBegin()
7589 
    while True:
7590 
      (fname, ftype, fid) = iprot.readFieldBegin()
7591 
      if ftype == TType.STOP:
7592 
        break
7593 
      if fid == 0:
7594 
        if ftype == TType.BOOL:
7595 
          self.success = iprot.readBool();
7596 
        else:
7597 
          iprot.skip(ftype)
7598 
      elif fid == 1:
7599 
        if ftype == TType.STRUCT:
7600 
          self.ex = TransactionServiceException()
7601 
          self.ex.read(iprot)
7602 
        else:
7603 
          iprot.skip(ftype)
7604 
      else:
7605 
        iprot.skip(ftype)
7606 
      iprot.readFieldEnd()
7607 
    iprot.readStructEnd()
7608 
 
7609 
  def write(self, oprot):
7610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7612 
      return
7613 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7614 
    if self.success is not None:
94 ashish 7615 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7616 
      oprot.writeBool(self.success)
7617 
      oprot.writeFieldEnd()
3431 rajveer 7618 
    if self.ex is not None:
94 ashish 7619 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7620 
      self.ex.write(oprot)
7621 
      oprot.writeFieldEnd()
7622 
    oprot.writeFieldStop()
7623 
    oprot.writeStructEnd()
7624 
 
3431 rajveer 7625 
  def validate(self):
7626 
    return
7627 
 
7628 
 
94 ashish 7629 
  def __repr__(self):
7630 
    L = ['%s=%r' % (key, value)
7631 
      for key, value in self.__dict__.iteritems()]
7632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7633 
 
7634 
  def __eq__(self, other):
7635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7636 
 
7637 
  def __ne__(self, other):
7638 
    return not (self == other)
7639 
 
1398 varun.gupt 7640 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7641 
  """
7642 
  Attributes:
7643 
   - transactionId
7644 
  """
7645 
 
7646 
  thrift_spec = (
7647 
    None, # 0
7648 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7649 
  )
7650 
 
7651 
  def __init__(self, transactionId=None,):
7652 
    self.transactionId = transactionId
7653 
 
7654 
  def read(self, iprot):
7655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7657 
      return
7658 
    iprot.readStructBegin()
7659 
    while True:
7660 
      (fname, ftype, fid) = iprot.readFieldBegin()
7661 
      if ftype == TType.STOP:
7662 
        break
7663 
      if fid == 1:
7664 
        if ftype == TType.I64:
7665 
          self.transactionId = iprot.readI64();
7666 
        else:
7667 
          iprot.skip(ftype)
7668 
      else:
7669 
        iprot.skip(ftype)
7670 
      iprot.readFieldEnd()
7671 
    iprot.readStructEnd()
7672 
 
7673 
  def write(self, oprot):
7674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7676 
      return
1398 varun.gupt 7677 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7678 
    if self.transactionId is not None:
1382 varun.gupt 7679 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7680 
      oprot.writeI64(self.transactionId)
7681 
      oprot.writeFieldEnd()
7682 
    oprot.writeFieldStop()
7683 
    oprot.writeStructEnd()
7684 
 
3431 rajveer 7685 
  def validate(self):
7686 
    return
7687 
 
7688 
 
1382 varun.gupt 7689 
  def __repr__(self):
7690 
    L = ['%s=%r' % (key, value)
7691 
      for key, value in self.__dict__.iteritems()]
7692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7693 
 
7694 
  def __eq__(self, other):
7695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7696 
 
7697 
  def __ne__(self, other):
7698 
    return not (self == other)
7699 
 
1398 varun.gupt 7700 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7701 
  """
7702 
  Attributes:
7703 
   - success
7704 
   - ex
7705 
  """
7706 
 
7707 
  thrift_spec = (
7708 
    (0, TType.BOOL, 'success', None, None, ), # 0
7709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7710 
  )
7711 
 
7712 
  def __init__(self, success=None, ex=None,):
7713 
    self.success = success
7714 
    self.ex = ex
7715 
 
7716 
  def read(self, iprot):
7717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7719 
      return
7720 
    iprot.readStructBegin()
7721 
    while True:
7722 
      (fname, ftype, fid) = iprot.readFieldBegin()
7723 
      if ftype == TType.STOP:
7724 
        break
7725 
      if fid == 0:
7726 
        if ftype == TType.BOOL:
7727 
          self.success = iprot.readBool();
7728 
        else:
7729 
          iprot.skip(ftype)
7730 
      elif fid == 1:
7731 
        if ftype == TType.STRUCT:
7732 
          self.ex = TransactionServiceException()
7733 
          self.ex.read(iprot)
7734 
        else:
7735 
          iprot.skip(ftype)
7736 
      else:
7737 
        iprot.skip(ftype)
7738 
      iprot.readFieldEnd()
7739 
    iprot.readStructEnd()
7740 
 
7741 
  def write(self, oprot):
7742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7744 
      return
1398 varun.gupt 7745 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7746 
    if self.success is not None:
1382 varun.gupt 7747 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7748 
      oprot.writeBool(self.success)
7749 
      oprot.writeFieldEnd()
3431 rajveer 7750 
    if self.ex is not None:
1382 varun.gupt 7751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7752 
      self.ex.write(oprot)
7753 
      oprot.writeFieldEnd()
7754 
    oprot.writeFieldStop()
7755 
    oprot.writeStructEnd()
7756 
 
3431 rajveer 7757 
  def validate(self):
7758 
    return
7759 
 
7760 
 
1382 varun.gupt 7761 
  def __repr__(self):
7762 
    L = ['%s=%r' % (key, value)
7763 
      for key, value in self.__dict__.iteritems()]
7764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7765 
 
7766 
  def __eq__(self, other):
7767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7768 
 
7769 
  def __ne__(self, other):
7770 
    return not (self == other)
7771 
 
483 rajveer 7772 
class getAllOrders_args:
94 ashish 7773 
  """
7774 
  Attributes:
4801 anupam.sin 7775 
   - statuses
483 rajveer 7776 
   - from_date
7777 
   - to_date
7778 
   - warehouse_id
94 ashish 7779 
  """
7780 
 
7781 
  thrift_spec = (
7782 
    None, # 0
4801 anupam.sin 7783 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7784 
    (2, TType.I64, 'from_date', None, None, ), # 2
7785 
    (3, TType.I64, 'to_date', None, None, ), # 3
7786 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7787 
  )
7788 
 
4801 anupam.sin 7789 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7790 
    self.statuses = statuses
483 rajveer 7791 
    self.from_date = from_date
7792 
    self.to_date = to_date
7793 
    self.warehouse_id = warehouse_id
94 ashish 7794 
 
7795 
  def read(self, iprot):
7796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7798 
      return
7799 
    iprot.readStructBegin()
7800 
    while True:
7801 
      (fname, ftype, fid) = iprot.readFieldBegin()
7802 
      if ftype == TType.STOP:
7803 
        break
7804 
      if fid == 1:
4801 anupam.sin 7805 
        if ftype == TType.LIST:
7806 
          self.statuses = []
5031 varun.gupt 7807 
          (_etype80, _size77) = iprot.readListBegin()
7808 
          for _i81 in xrange(_size77):
7809 
            _elem82 = iprot.readI32();
7810 
            self.statuses.append(_elem82)
4801 anupam.sin 7811 
          iprot.readListEnd()
94 ashish 7812 
        else:
7813 
          iprot.skip(ftype)
483 rajveer 7814 
      elif fid == 2:
7815 
        if ftype == TType.I64:
7816 
          self.from_date = iprot.readI64();
94 ashish 7817 
        else:
7818 
          iprot.skip(ftype)
483 rajveer 7819 
      elif fid == 3:
7820 
        if ftype == TType.I64:
7821 
          self.to_date = iprot.readI64();
94 ashish 7822 
        else:
7823 
          iprot.skip(ftype)
483 rajveer 7824 
      elif fid == 4:
94 ashish 7825 
        if ftype == TType.I64:
483 rajveer 7826 
          self.warehouse_id = iprot.readI64();
94 ashish 7827 
        else:
7828 
          iprot.skip(ftype)
7829 
      else:
7830 
        iprot.skip(ftype)
7831 
      iprot.readFieldEnd()
7832 
    iprot.readStructEnd()
7833 
 
7834 
  def write(self, oprot):
7835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7837 
      return
483 rajveer 7838 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7839 
    if self.statuses is not None:
7840 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7841 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7842 
      for iter83 in self.statuses:
7843 
        oprot.writeI32(iter83)
4801 anupam.sin 7844 
      oprot.writeListEnd()
94 ashish 7845 
      oprot.writeFieldEnd()
3431 rajveer 7846 
    if self.from_date is not None:
483 rajveer 7847 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7848 
      oprot.writeI64(self.from_date)
94 ashish 7849 
      oprot.writeFieldEnd()
3431 rajveer 7850 
    if self.to_date is not None:
483 rajveer 7851 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7852 
      oprot.writeI64(self.to_date)
94 ashish 7853 
      oprot.writeFieldEnd()
3431 rajveer 7854 
    if self.warehouse_id is not None:
483 rajveer 7855 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7856 
      oprot.writeI64(self.warehouse_id)
94 ashish 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 
 
483 rajveer 7876 
class getAllOrders_result:
94 ashish 7877 
  """
7878 
  Attributes:
7879 
   - success
7880 
   - ex
7881 
  """
7882 
 
7883 
  thrift_spec = (
483 rajveer 7884 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7886 
  )
7887 
 
7888 
  def __init__(self, success=None, ex=None,):
7889 
    self.success = success
7890 
    self.ex = ex
7891 
 
7892 
  def read(self, iprot):
7893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7895 
      return
7896 
    iprot.readStructBegin()
7897 
    while True:
7898 
      (fname, ftype, fid) = iprot.readFieldBegin()
7899 
      if ftype == TType.STOP:
7900 
        break
7901 
      if fid == 0:
483 rajveer 7902 
        if ftype == TType.LIST:
7903 
          self.success = []
5031 varun.gupt 7904 
          (_etype87, _size84) = iprot.readListBegin()
7905 
          for _i88 in xrange(_size84):
7906 
            _elem89 = Order()
7907 
            _elem89.read(iprot)
7908 
            self.success.append(_elem89)
483 rajveer 7909 
          iprot.readListEnd()
94 ashish 7910 
        else:
7911 
          iprot.skip(ftype)
7912 
      elif fid == 1:
7913 
        if ftype == TType.STRUCT:
7914 
          self.ex = TransactionServiceException()
7915 
          self.ex.read(iprot)
7916 
        else:
7917 
          iprot.skip(ftype)
7918 
      else:
7919 
        iprot.skip(ftype)
7920 
      iprot.readFieldEnd()
7921 
    iprot.readStructEnd()
7922 
 
7923 
  def write(self, oprot):
7924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7926 
      return
483 rajveer 7927 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7928 
    if self.success is not None:
483 rajveer 7929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7931 
      for iter90 in self.success:
7932 
        iter90.write(oprot)
483 rajveer 7933 
      oprot.writeListEnd()
94 ashish 7934 
      oprot.writeFieldEnd()
3431 rajveer 7935 
    if self.ex is not None:
94 ashish 7936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7937 
      self.ex.write(oprot)
7938 
      oprot.writeFieldEnd()
7939 
    oprot.writeFieldStop()
7940 
    oprot.writeStructEnd()
7941 
 
3431 rajveer 7942 
  def validate(self):
7943 
    return
7944 
 
7945 
 
94 ashish 7946 
  def __repr__(self):
7947 
    L = ['%s=%r' % (key, value)
7948 
      for key, value in self.__dict__.iteritems()]
7949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7950 
 
7951 
  def __eq__(self, other):
7952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7953 
 
7954 
  def __ne__(self, other):
7955 
    return not (self == other)
7956 
 
4133 chandransh 7957 
class getOrdersInBatch_args:
7958 
  """
7959 
  Attributes:
7960 
   - statuses
7961 
   - offset
7962 
   - limit
7963 
   - warehouse_id
7964 
  """
7965 
 
7966 
  thrift_spec = (
7967 
    None, # 0
7968 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7969 
    (2, TType.I64, 'offset', None, None, ), # 2
7970 
    (3, TType.I64, 'limit', None, None, ), # 3
7971 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7972 
  )
7973 
 
7974 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7975 
    self.statuses = statuses
7976 
    self.offset = offset
7977 
    self.limit = limit
7978 
    self.warehouse_id = warehouse_id
7979 
 
7980 
  def read(self, iprot):
7981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7983 
      return
7984 
    iprot.readStructBegin()
7985 
    while True:
7986 
      (fname, ftype, fid) = iprot.readFieldBegin()
7987 
      if ftype == TType.STOP:
7988 
        break
7989 
      if fid == 1:
7990 
        if ftype == TType.LIST:
7991 
          self.statuses = []
5031 varun.gupt 7992 
          (_etype94, _size91) = iprot.readListBegin()
7993 
          for _i95 in xrange(_size91):
7994 
            _elem96 = iprot.readI32();
7995 
            self.statuses.append(_elem96)
4133 chandransh 7996 
          iprot.readListEnd()
7997 
        else:
7998 
          iprot.skip(ftype)
7999 
      elif fid == 2:
8000 
        if ftype == TType.I64:
8001 
          self.offset = iprot.readI64();
8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 3:
8005 
        if ftype == TType.I64:
8006 
          self.limit = iprot.readI64();
8007 
        else:
8008 
          iprot.skip(ftype)
8009 
      elif fid == 4:
8010 
        if ftype == TType.I64:
8011 
          self.warehouse_id = iprot.readI64();
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      else:
8015 
        iprot.skip(ftype)
8016 
      iprot.readFieldEnd()
8017 
    iprot.readStructEnd()
8018 
 
8019 
  def write(self, oprot):
8020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8022 
      return
8023 
    oprot.writeStructBegin('getOrdersInBatch_args')
8024 
    if self.statuses is not None:
8025 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8026 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8027 
      for iter97 in self.statuses:
8028 
        oprot.writeI32(iter97)
4133 chandransh 8029 
      oprot.writeListEnd()
8030 
      oprot.writeFieldEnd()
8031 
    if self.offset is not None:
8032 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8033 
      oprot.writeI64(self.offset)
8034 
      oprot.writeFieldEnd()
8035 
    if self.limit is not None:
8036 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8037 
      oprot.writeI64(self.limit)
8038 
      oprot.writeFieldEnd()
8039 
    if self.warehouse_id is not None:
8040 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8041 
      oprot.writeI64(self.warehouse_id)
8042 
      oprot.writeFieldEnd()
8043 
    oprot.writeFieldStop()
8044 
    oprot.writeStructEnd()
8045 
 
8046 
  def validate(self):
8047 
    return
8048 
 
8049 
 
8050 
  def __repr__(self):
8051 
    L = ['%s=%r' % (key, value)
8052 
      for key, value in self.__dict__.iteritems()]
8053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8054 
 
8055 
  def __eq__(self, other):
8056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8057 
 
8058 
  def __ne__(self, other):
8059 
    return not (self == other)
8060 
 
8061 
class getOrdersInBatch_result:
8062 
  """
8063 
  Attributes:
8064 
   - success
8065 
   - ex
8066 
  """
8067 
 
8068 
  thrift_spec = (
8069 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8071 
  )
8072 
 
8073 
  def __init__(self, success=None, ex=None,):
8074 
    self.success = success
8075 
    self.ex = ex
8076 
 
8077 
  def read(self, iprot):
8078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8080 
      return
8081 
    iprot.readStructBegin()
8082 
    while True:
8083 
      (fname, ftype, fid) = iprot.readFieldBegin()
8084 
      if ftype == TType.STOP:
8085 
        break
8086 
      if fid == 0:
8087 
        if ftype == TType.LIST:
8088 
          self.success = []
5031 varun.gupt 8089 
          (_etype101, _size98) = iprot.readListBegin()
8090 
          for _i102 in xrange(_size98):
8091 
            _elem103 = Order()
8092 
            _elem103.read(iprot)
8093 
            self.success.append(_elem103)
4133 chandransh 8094 
          iprot.readListEnd()
8095 
        else:
8096 
          iprot.skip(ftype)
8097 
      elif fid == 1:
8098 
        if ftype == TType.STRUCT:
8099 
          self.ex = TransactionServiceException()
8100 
          self.ex.read(iprot)
8101 
        else:
8102 
          iprot.skip(ftype)
8103 
      else:
8104 
        iprot.skip(ftype)
8105 
      iprot.readFieldEnd()
8106 
    iprot.readStructEnd()
8107 
 
8108 
  def write(self, oprot):
8109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8111 
      return
8112 
    oprot.writeStructBegin('getOrdersInBatch_result')
8113 
    if self.success is not None:
8114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8116 
      for iter104 in self.success:
8117 
        iter104.write(oprot)
4133 chandransh 8118 
      oprot.writeListEnd()
8119 
      oprot.writeFieldEnd()
8120 
    if self.ex is not None:
8121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8122 
      self.ex.write(oprot)
8123 
      oprot.writeFieldEnd()
8124 
    oprot.writeFieldStop()
8125 
    oprot.writeStructEnd()
8126 
 
8127 
  def validate(self):
8128 
    return
8129 
 
8130 
 
8131 
  def __repr__(self):
8132 
    L = ['%s=%r' % (key, value)
8133 
      for key, value in self.__dict__.iteritems()]
8134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8135 
 
8136 
  def __eq__(self, other):
8137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8138 
 
8139 
  def __ne__(self, other):
8140 
    return not (self == other)
8141 
 
8142 
class getOrderCount_args:
8143 
  """
8144 
  Attributes:
8145 
   - statuses
8146 
   - warehouseId
8147 
  """
8148 
 
8149 
  thrift_spec = (
8150 
    None, # 0
8151 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8152 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8153 
  )
8154 
 
8155 
  def __init__(self, statuses=None, warehouseId=None,):
8156 
    self.statuses = statuses
8157 
    self.warehouseId = warehouseId
8158 
 
8159 
  def read(self, iprot):
8160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8162 
      return
8163 
    iprot.readStructBegin()
8164 
    while True:
8165 
      (fname, ftype, fid) = iprot.readFieldBegin()
8166 
      if ftype == TType.STOP:
8167 
        break
8168 
      if fid == 1:
8169 
        if ftype == TType.LIST:
8170 
          self.statuses = []
5031 varun.gupt 8171 
          (_etype108, _size105) = iprot.readListBegin()
8172 
          for _i109 in xrange(_size105):
8173 
            _elem110 = iprot.readI32();
8174 
            self.statuses.append(_elem110)
4133 chandransh 8175 
          iprot.readListEnd()
8176 
        else:
8177 
          iprot.skip(ftype)
8178 
      elif fid == 2:
8179 
        if ftype == TType.I64:
8180 
          self.warehouseId = iprot.readI64();
8181 
        else:
8182 
          iprot.skip(ftype)
8183 
      else:
8184 
        iprot.skip(ftype)
8185 
      iprot.readFieldEnd()
8186 
    iprot.readStructEnd()
8187 
 
8188 
  def write(self, oprot):
8189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8191 
      return
8192 
    oprot.writeStructBegin('getOrderCount_args')
8193 
    if self.statuses is not None:
8194 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8195 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8196 
      for iter111 in self.statuses:
8197 
        oprot.writeI32(iter111)
4133 chandransh 8198 
      oprot.writeListEnd()
8199 
      oprot.writeFieldEnd()
8200 
    if self.warehouseId is not None:
8201 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8202 
      oprot.writeI64(self.warehouseId)
8203 
      oprot.writeFieldEnd()
8204 
    oprot.writeFieldStop()
8205 
    oprot.writeStructEnd()
8206 
 
8207 
  def validate(self):
8208 
    return
8209 
 
8210 
 
8211 
  def __repr__(self):
8212 
    L = ['%s=%r' % (key, value)
8213 
      for key, value in self.__dict__.iteritems()]
8214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8215 
 
8216 
  def __eq__(self, other):
8217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8218 
 
8219 
  def __ne__(self, other):
8220 
    return not (self == other)
8221 
 
8222 
class getOrderCount_result:
8223 
  """
8224 
  Attributes:
8225 
   - success
8226 
   - ex
8227 
  """
8228 
 
8229 
  thrift_spec = (
8230 
    (0, TType.I32, 'success', None, None, ), # 0
8231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8232 
  )
8233 
 
8234 
  def __init__(self, success=None, ex=None,):
8235 
    self.success = success
8236 
    self.ex = ex
8237 
 
8238 
  def read(self, iprot):
8239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8241 
      return
8242 
    iprot.readStructBegin()
8243 
    while True:
8244 
      (fname, ftype, fid) = iprot.readFieldBegin()
8245 
      if ftype == TType.STOP:
8246 
        break
8247 
      if fid == 0:
8248 
        if ftype == TType.I32:
8249 
          self.success = iprot.readI32();
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      elif fid == 1:
8253 
        if ftype == TType.STRUCT:
8254 
          self.ex = TransactionServiceException()
8255 
          self.ex.read(iprot)
8256 
        else:
8257 
          iprot.skip(ftype)
8258 
      else:
8259 
        iprot.skip(ftype)
8260 
      iprot.readFieldEnd()
8261 
    iprot.readStructEnd()
8262 
 
8263 
  def write(self, oprot):
8264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8266 
      return
8267 
    oprot.writeStructBegin('getOrderCount_result')
8268 
    if self.success is not None:
8269 
      oprot.writeFieldBegin('success', TType.I32, 0)
8270 
      oprot.writeI32(self.success)
8271 
      oprot.writeFieldEnd()
8272 
    if self.ex is not None:
8273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8274 
      self.ex.write(oprot)
8275 
      oprot.writeFieldEnd()
8276 
    oprot.writeFieldStop()
8277 
    oprot.writeStructEnd()
8278 
 
8279 
  def validate(self):
8280 
    return
8281 
 
8282 
 
8283 
  def __repr__(self):
8284 
    L = ['%s=%r' % (key, value)
8285 
      for key, value in self.__dict__.iteritems()]
8286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8287 
 
8288 
  def __eq__(self, other):
8289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8290 
 
8291 
  def __ne__(self, other):
8292 
    return not (self == other)
8293 
 
999 varun.gupt 8294 
class getOrdersByBillingDate_args:
8295 
  """
8296 
  Attributes:
8297 
   - status
8298 
   - start_billing_date
8299 
   - end_billing_date
8300 
   - warehouse_id
8301 
  """
8302 
 
8303 
  thrift_spec = (
8304 
    None, # 0
8305 
    (1, TType.I32, 'status', None, None, ), # 1
8306 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8307 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8308 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8309 
  )
8310 
 
8311 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8312 
    self.status = status
8313 
    self.start_billing_date = start_billing_date
8314 
    self.end_billing_date = end_billing_date
8315 
    self.warehouse_id = warehouse_id
8316 
 
8317 
  def read(self, iprot):
8318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8320 
      return
8321 
    iprot.readStructBegin()
8322 
    while True:
8323 
      (fname, ftype, fid) = iprot.readFieldBegin()
8324 
      if ftype == TType.STOP:
8325 
        break
8326 
      if fid == 1:
8327 
        if ftype == TType.I32:
8328 
          self.status = iprot.readI32();
8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      elif fid == 2:
8332 
        if ftype == TType.I64:
8333 
          self.start_billing_date = iprot.readI64();
8334 
        else:
8335 
          iprot.skip(ftype)
8336 
      elif fid == 3:
8337 
        if ftype == TType.I64:
8338 
          self.end_billing_date = iprot.readI64();
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      elif fid == 4:
8342 
        if ftype == TType.I64:
8343 
          self.warehouse_id = iprot.readI64();
8344 
        else:
8345 
          iprot.skip(ftype)
8346 
      else:
8347 
        iprot.skip(ftype)
8348 
      iprot.readFieldEnd()
8349 
    iprot.readStructEnd()
8350 
 
8351 
  def write(self, oprot):
8352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8354 
      return
8355 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8356 
    if self.status is not None:
999 varun.gupt 8357 
      oprot.writeFieldBegin('status', TType.I32, 1)
8358 
      oprot.writeI32(self.status)
8359 
      oprot.writeFieldEnd()
3431 rajveer 8360 
    if self.start_billing_date is not None:
999 varun.gupt 8361 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8362 
      oprot.writeI64(self.start_billing_date)
8363 
      oprot.writeFieldEnd()
3431 rajveer 8364 
    if self.end_billing_date is not None:
999 varun.gupt 8365 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8366 
      oprot.writeI64(self.end_billing_date)
8367 
      oprot.writeFieldEnd()
3431 rajveer 8368 
    if self.warehouse_id is not None:
999 varun.gupt 8369 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8370 
      oprot.writeI64(self.warehouse_id)
8371 
      oprot.writeFieldEnd()
8372 
    oprot.writeFieldStop()
8373 
    oprot.writeStructEnd()
8374 
 
3431 rajveer 8375 
  def validate(self):
8376 
    return
8377 
 
8378 
 
999 varun.gupt 8379 
  def __repr__(self):
8380 
    L = ['%s=%r' % (key, value)
8381 
      for key, value in self.__dict__.iteritems()]
8382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8383 
 
8384 
  def __eq__(self, other):
8385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8386 
 
8387 
  def __ne__(self, other):
8388 
    return not (self == other)
8389 
 
8390 
class getOrdersByBillingDate_result:
8391 
  """
8392 
  Attributes:
8393 
   - success
8394 
   - ex
8395 
  """
8396 
 
8397 
  thrift_spec = (
8398 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8400 
  )
8401 
 
8402 
  def __init__(self, success=None, ex=None,):
8403 
    self.success = success
8404 
    self.ex = ex
8405 
 
8406 
  def read(self, iprot):
8407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8409 
      return
8410 
    iprot.readStructBegin()
8411 
    while True:
8412 
      (fname, ftype, fid) = iprot.readFieldBegin()
8413 
      if ftype == TType.STOP:
8414 
        break
8415 
      if fid == 0:
8416 
        if ftype == TType.LIST:
8417 
          self.success = []
5031 varun.gupt 8418 
          (_etype115, _size112) = iprot.readListBegin()
8419 
          for _i116 in xrange(_size112):
8420 
            _elem117 = Order()
8421 
            _elem117.read(iprot)
8422 
            self.success.append(_elem117)
999 varun.gupt 8423 
          iprot.readListEnd()
8424 
        else:
8425 
          iprot.skip(ftype)
8426 
      elif fid == 1:
8427 
        if ftype == TType.STRUCT:
8428 
          self.ex = TransactionServiceException()
8429 
          self.ex.read(iprot)
8430 
        else:
8431 
          iprot.skip(ftype)
8432 
      else:
8433 
        iprot.skip(ftype)
8434 
      iprot.readFieldEnd()
8435 
    iprot.readStructEnd()
8436 
 
8437 
  def write(self, oprot):
8438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8440 
      return
8441 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8442 
    if self.success is not None:
999 varun.gupt 8443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8444 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8445 
      for iter118 in self.success:
8446 
        iter118.write(oprot)
999 varun.gupt 8447 
      oprot.writeListEnd()
8448 
      oprot.writeFieldEnd()
3431 rajveer 8449 
    if self.ex is not None:
999 varun.gupt 8450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8451 
      self.ex.write(oprot)
8452 
      oprot.writeFieldEnd()
8453 
    oprot.writeFieldStop()
8454 
    oprot.writeStructEnd()
8455 
 
3431 rajveer 8456 
  def validate(self):
8457 
    return
8458 
 
8459 
 
999 varun.gupt 8460 
  def __repr__(self):
8461 
    L = ['%s=%r' % (key, value)
8462 
      for key, value in self.__dict__.iteritems()]
8463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8464 
 
8465 
  def __eq__(self, other):
8466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8467 
 
8468 
  def __ne__(self, other):
8469 
    return not (self == other)
8470 
 
3427 chandransh 8471 
class getOrdersByShippingDate_args:
8472 
  """
8473 
  Attributes:
8474 
   - fromShippingDate
8475 
   - toShippingDate
8476 
   - providerId
8477 
   - warehouseId
3451 chandransh 8478 
   - cod
3427 chandransh 8479 
  """
8480 
 
8481 
  thrift_spec = (
8482 
    None, # 0
8483 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8484 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8485 
    (3, TType.I64, 'providerId', None, None, ), # 3
8486 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8487 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8488 
  )
8489 
 
3451 chandransh 8490 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8491 
    self.fromShippingDate = fromShippingDate
8492 
    self.toShippingDate = toShippingDate
8493 
    self.providerId = providerId
8494 
    self.warehouseId = warehouseId
3451 chandransh 8495 
    self.cod = cod
3427 chandransh 8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      if fid == 1:
8507 
        if ftype == TType.I64:
8508 
          self.fromShippingDate = iprot.readI64();
8509 
        else:
8510 
          iprot.skip(ftype)
8511 
      elif fid == 2:
8512 
        if ftype == TType.I64:
8513 
          self.toShippingDate = iprot.readI64();
8514 
        else:
8515 
          iprot.skip(ftype)
8516 
      elif fid == 3:
8517 
        if ftype == TType.I64:
8518 
          self.providerId = iprot.readI64();
8519 
        else:
8520 
          iprot.skip(ftype)
8521 
      elif fid == 4:
8522 
        if ftype == TType.I64:
8523 
          self.warehouseId = iprot.readI64();
8524 
        else:
8525 
          iprot.skip(ftype)
3451 chandransh 8526 
      elif fid == 5:
8527 
        if ftype == TType.BOOL:
8528 
          self.cod = iprot.readBool();
8529 
        else:
8530 
          iprot.skip(ftype)
3427 chandransh 8531 
      else:
8532 
        iprot.skip(ftype)
8533 
      iprot.readFieldEnd()
8534 
    iprot.readStructEnd()
8535 
 
8536 
  def write(self, oprot):
8537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8539 
      return
8540 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8541 
    if self.fromShippingDate is not None:
3427 chandransh 8542 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8543 
      oprot.writeI64(self.fromShippingDate)
8544 
      oprot.writeFieldEnd()
3431 rajveer 8545 
    if self.toShippingDate is not None:
3427 chandransh 8546 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8547 
      oprot.writeI64(self.toShippingDate)
8548 
      oprot.writeFieldEnd()
3431 rajveer 8549 
    if self.providerId is not None:
3427 chandransh 8550 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8551 
      oprot.writeI64(self.providerId)
8552 
      oprot.writeFieldEnd()
3431 rajveer 8553 
    if self.warehouseId is not None:
3427 chandransh 8554 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8555 
      oprot.writeI64(self.warehouseId)
8556 
      oprot.writeFieldEnd()
3451 chandransh 8557 
    if self.cod is not None:
8558 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8559 
      oprot.writeBool(self.cod)
8560 
      oprot.writeFieldEnd()
3427 chandransh 8561 
    oprot.writeFieldStop()
8562 
    oprot.writeStructEnd()
8563 
 
3431 rajveer 8564 
  def validate(self):
8565 
    return
8566 
 
8567 
 
3427 chandransh 8568 
  def __repr__(self):
8569 
    L = ['%s=%r' % (key, value)
8570 
      for key, value in self.__dict__.iteritems()]
8571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8572 
 
8573 
  def __eq__(self, other):
8574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8575 
 
8576 
  def __ne__(self, other):
8577 
    return not (self == other)
8578 
 
8579 
class getOrdersByShippingDate_result:
8580 
  """
8581 
  Attributes:
8582 
   - success
8583 
   - ex
8584 
  """
8585 
 
8586 
  thrift_spec = (
8587 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8589 
  )
8590 
 
8591 
  def __init__(self, success=None, ex=None,):
8592 
    self.success = success
8593 
    self.ex = ex
8594 
 
8595 
  def read(self, iprot):
8596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8598 
      return
8599 
    iprot.readStructBegin()
8600 
    while True:
8601 
      (fname, ftype, fid) = iprot.readFieldBegin()
8602 
      if ftype == TType.STOP:
8603 
        break
8604 
      if fid == 0:
8605 
        if ftype == TType.LIST:
8606 
          self.success = []
5031 varun.gupt 8607 
          (_etype122, _size119) = iprot.readListBegin()
8608 
          for _i123 in xrange(_size119):
8609 
            _elem124 = Order()
8610 
            _elem124.read(iprot)
8611 
            self.success.append(_elem124)
3427 chandransh 8612 
          iprot.readListEnd()
8613 
        else:
8614 
          iprot.skip(ftype)
8615 
      elif fid == 1:
8616 
        if ftype == TType.STRUCT:
8617 
          self.ex = TransactionServiceException()
8618 
          self.ex.read(iprot)
8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      else:
8622 
        iprot.skip(ftype)
8623 
      iprot.readFieldEnd()
8624 
    iprot.readStructEnd()
8625 
 
8626 
  def write(self, oprot):
8627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8629 
      return
8630 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8631 
    if self.success is not None:
3427 chandransh 8632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8634 
      for iter125 in self.success:
8635 
        iter125.write(oprot)
3427 chandransh 8636 
      oprot.writeListEnd()
8637 
      oprot.writeFieldEnd()
3431 rajveer 8638 
    if self.ex is not None:
3427 chandransh 8639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8640 
      self.ex.write(oprot)
8641 
      oprot.writeFieldEnd()
8642 
    oprot.writeFieldStop()
8643 
    oprot.writeStructEnd()
8644 
 
3431 rajveer 8645 
  def validate(self):
8646 
    return
8647 
 
8648 
 
3427 chandransh 8649 
  def __repr__(self):
8650 
    L = ['%s=%r' % (key, value)
8651 
      for key, value in self.__dict__.iteritems()]
8652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8653 
 
8654 
  def __eq__(self, other):
8655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8656 
 
8657 
  def __ne__(self, other):
8658 
    return not (self == other)
8659 
 
1382 varun.gupt 8660 
class getReturnableOrdersForCustomer_args:
8661 
  """
8662 
  Attributes:
8663 
   - customer_id
8664 
   - limit
8665 
  """
8666 
 
8667 
  thrift_spec = (
8668 
    None, # 0
8669 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8670 
    (2, TType.I64, 'limit', None, None, ), # 2
8671 
  )
8672 
 
8673 
  def __init__(self, customer_id=None, limit=None,):
8674 
    self.customer_id = customer_id
8675 
    self.limit = limit
8676 
 
8677 
  def read(self, iprot):
8678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8680 
      return
8681 
    iprot.readStructBegin()
8682 
    while True:
8683 
      (fname, ftype, fid) = iprot.readFieldBegin()
8684 
      if ftype == TType.STOP:
8685 
        break
8686 
      if fid == 1:
8687 
        if ftype == TType.I64:
8688 
          self.customer_id = iprot.readI64();
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      elif fid == 2:
8692 
        if ftype == TType.I64:
8693 
          self.limit = iprot.readI64();
8694 
        else:
8695 
          iprot.skip(ftype)
8696 
      else:
8697 
        iprot.skip(ftype)
8698 
      iprot.readFieldEnd()
8699 
    iprot.readStructEnd()
8700 
 
8701 
  def write(self, oprot):
8702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8704 
      return
8705 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8706 
    if self.customer_id is not None:
1382 varun.gupt 8707 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8708 
      oprot.writeI64(self.customer_id)
8709 
      oprot.writeFieldEnd()
3431 rajveer 8710 
    if self.limit is not None:
1382 varun.gupt 8711 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8712 
      oprot.writeI64(self.limit)
8713 
      oprot.writeFieldEnd()
8714 
    oprot.writeFieldStop()
8715 
    oprot.writeStructEnd()
8716 
 
3431 rajveer 8717 
  def validate(self):
8718 
    return
8719 
 
8720 
 
1382 varun.gupt 8721 
  def __repr__(self):
8722 
    L = ['%s=%r' % (key, value)
8723 
      for key, value in self.__dict__.iteritems()]
8724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8725 
 
8726 
  def __eq__(self, other):
8727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8728 
 
8729 
  def __ne__(self, other):
8730 
    return not (self == other)
8731 
 
8732 
class getReturnableOrdersForCustomer_result:
8733 
  """
8734 
  Attributes:
8735 
   - success
8736 
   - ex
8737 
  """
8738 
 
8739 
  thrift_spec = (
8740 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8742 
  )
8743 
 
8744 
  def __init__(self, success=None, ex=None,):
8745 
    self.success = success
8746 
    self.ex = ex
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 0:
8758 
        if ftype == TType.LIST:
8759 
          self.success = []
5031 varun.gupt 8760 
          (_etype129, _size126) = iprot.readListBegin()
8761 
          for _i130 in xrange(_size126):
8762 
            _elem131 = iprot.readI64();
8763 
            self.success.append(_elem131)
1382 varun.gupt 8764 
          iprot.readListEnd()
8765 
        else:
8766 
          iprot.skip(ftype)
8767 
      elif fid == 1:
8768 
        if ftype == TType.STRUCT:
8769 
          self.ex = TransactionServiceException()
8770 
          self.ex.read(iprot)
8771 
        else:
8772 
          iprot.skip(ftype)
8773 
      else:
8774 
        iprot.skip(ftype)
8775 
      iprot.readFieldEnd()
8776 
    iprot.readStructEnd()
8777 
 
8778 
  def write(self, oprot):
8779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8781 
      return
8782 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8783 
    if self.success is not None:
1382 varun.gupt 8784 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8785 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8786 
      for iter132 in self.success:
8787 
        oprot.writeI64(iter132)
1382 varun.gupt 8788 
      oprot.writeListEnd()
8789 
      oprot.writeFieldEnd()
3431 rajveer 8790 
    if self.ex is not None:
1382 varun.gupt 8791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8792 
      self.ex.write(oprot)
8793 
      oprot.writeFieldEnd()
8794 
    oprot.writeFieldStop()
8795 
    oprot.writeStructEnd()
8796 
 
3431 rajveer 8797 
  def validate(self):
8798 
    return
8799 
 
8800 
 
1382 varun.gupt 8801 
  def __repr__(self):
8802 
    L = ['%s=%r' % (key, value)
8803 
      for key, value in self.__dict__.iteritems()]
8804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8805 
 
8806 
  def __eq__(self, other):
8807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8808 
 
8809 
  def __ne__(self, other):
8810 
    return not (self == other)
8811 
 
8812 
class getCancellableOrdersForCustomer_args:
8813 
  """
8814 
  Attributes:
8815 
   - customer_id
8816 
   - limit
8817 
  """
8818 
 
8819 
  thrift_spec = (
8820 
    None, # 0
8821 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8822 
    (2, TType.I64, 'limit', None, None, ), # 2
8823 
  )
8824 
 
8825 
  def __init__(self, customer_id=None, limit=None,):
8826 
    self.customer_id = customer_id
8827 
    self.limit = limit
8828 
 
8829 
  def read(self, iprot):
8830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8832 
      return
8833 
    iprot.readStructBegin()
8834 
    while True:
8835 
      (fname, ftype, fid) = iprot.readFieldBegin()
8836 
      if ftype == TType.STOP:
8837 
        break
8838 
      if fid == 1:
8839 
        if ftype == TType.I64:
8840 
          self.customer_id = iprot.readI64();
8841 
        else:
8842 
          iprot.skip(ftype)
8843 
      elif fid == 2:
8844 
        if ftype == TType.I64:
8845 
          self.limit = iprot.readI64();
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('getCancellableOrdersForCustomer_args')
3431 rajveer 8858 
    if self.customer_id is not None:
1382 varun.gupt 8859 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8860 
      oprot.writeI64(self.customer_id)
8861 
      oprot.writeFieldEnd()
3431 rajveer 8862 
    if self.limit is not None:
1382 varun.gupt 8863 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8864 
      oprot.writeI64(self.limit)
8865 
      oprot.writeFieldEnd()
8866 
    oprot.writeFieldStop()
8867 
    oprot.writeStructEnd()
8868 
 
3431 rajveer 8869 
  def validate(self):
8870 
    return
8871 
 
8872 
 
1382 varun.gupt 8873 
  def __repr__(self):
8874 
    L = ['%s=%r' % (key, value)
8875 
      for key, value in self.__dict__.iteritems()]
8876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8877 
 
8878 
  def __eq__(self, other):
8879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8880 
 
8881 
  def __ne__(self, other):
8882 
    return not (self == other)
8883 
 
8884 
class getCancellableOrdersForCustomer_result:
8885 
  """
8886 
  Attributes:
8887 
   - success
8888 
   - ex
8889 
  """
8890 
 
8891 
  thrift_spec = (
8892 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8894 
  )
8895 
 
8896 
  def __init__(self, success=None, ex=None,):
8897 
    self.success = success
8898 
    self.ex = ex
8899 
 
8900 
  def read(self, iprot):
8901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8903 
      return
8904 
    iprot.readStructBegin()
8905 
    while True:
8906 
      (fname, ftype, fid) = iprot.readFieldBegin()
8907 
      if ftype == TType.STOP:
8908 
        break
8909 
      if fid == 0:
8910 
        if ftype == TType.LIST:
8911 
          self.success = []
5031 varun.gupt 8912 
          (_etype136, _size133) = iprot.readListBegin()
8913 
          for _i137 in xrange(_size133):
8914 
            _elem138 = iprot.readI64();
8915 
            self.success.append(_elem138)
1382 varun.gupt 8916 
          iprot.readListEnd()
8917 
        else:
8918 
          iprot.skip(ftype)
8919 
      elif fid == 1:
8920 
        if ftype == TType.STRUCT:
8921 
          self.ex = TransactionServiceException()
8922 
          self.ex.read(iprot)
8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      else:
8926 
        iprot.skip(ftype)
8927 
      iprot.readFieldEnd()
8928 
    iprot.readStructEnd()
8929 
 
8930 
  def write(self, oprot):
8931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8933 
      return
8934 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8935 
    if self.success is not None:
1382 varun.gupt 8936 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8937 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8938 
      for iter139 in self.success:
8939 
        oprot.writeI64(iter139)
1382 varun.gupt 8940 
      oprot.writeListEnd()
8941 
      oprot.writeFieldEnd()
3431 rajveer 8942 
    if self.ex is not None:
1382 varun.gupt 8943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8944 
      self.ex.write(oprot)
8945 
      oprot.writeFieldEnd()
8946 
    oprot.writeFieldStop()
8947 
    oprot.writeStructEnd()
8948 
 
3431 rajveer 8949 
  def validate(self):
8950 
    return
8951 
 
8952 
 
1382 varun.gupt 8953 
  def __repr__(self):
8954 
    L = ['%s=%r' % (key, value)
8955 
      for key, value in self.__dict__.iteritems()]
8956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8957 
 
8958 
  def __eq__(self, other):
8959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8960 
 
8961 
  def __ne__(self, other):
8962 
    return not (self == other)
8963 
 
483 rajveer 8964 
class changeOrderStatus_args:
94 ashish 8965 
  """
8966 
  Attributes:
483 rajveer 8967 
   - orderId
8968 
   - status
8969 
   - description
94 ashish 8970 
  """
8971 
 
8972 
  thrift_spec = (
8973 
    None, # 0
483 rajveer 8974 
    (1, TType.I64, 'orderId', None, None, ), # 1
8975 
    (2, TType.I32, 'status', None, None, ), # 2
8976 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8977 
  )
8978 
 
483 rajveer 8979 
  def __init__(self, orderId=None, status=None, description=None,):
8980 
    self.orderId = orderId
8981 
    self.status = status
8982 
    self.description = description
94 ashish 8983 
 
8984 
  def read(self, iprot):
8985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8987 
      return
8988 
    iprot.readStructBegin()
8989 
    while True:
8990 
      (fname, ftype, fid) = iprot.readFieldBegin()
8991 
      if ftype == TType.STOP:
8992 
        break
8993 
      if fid == 1:
8994 
        if ftype == TType.I64:
483 rajveer 8995 
          self.orderId = iprot.readI64();
94 ashish 8996 
        else:
8997 
          iprot.skip(ftype)
8998 
      elif fid == 2:
483 rajveer 8999 
        if ftype == TType.I32:
9000 
          self.status = iprot.readI32();
94 ashish 9001 
        else:
9002 
          iprot.skip(ftype)
483 rajveer 9003 
      elif fid == 3:
9004 
        if ftype == TType.STRING:
9005 
          self.description = iprot.readString();
9006 
        else:
9007 
          iprot.skip(ftype)
94 ashish 9008 
      else:
9009 
        iprot.skip(ftype)
9010 
      iprot.readFieldEnd()
9011 
    iprot.readStructEnd()
9012 
 
9013 
  def write(self, oprot):
9014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9016 
      return
483 rajveer 9017 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9018 
    if self.orderId is not None:
483 rajveer 9019 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9020 
      oprot.writeI64(self.orderId)
94 ashish 9021 
      oprot.writeFieldEnd()
3431 rajveer 9022 
    if self.status is not None:
483 rajveer 9023 
      oprot.writeFieldBegin('status', TType.I32, 2)
9024 
      oprot.writeI32(self.status)
94 ashish 9025 
      oprot.writeFieldEnd()
3431 rajveer 9026 
    if self.description is not None:
483 rajveer 9027 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9028 
      oprot.writeString(self.description)
9029 
      oprot.writeFieldEnd()
94 ashish 9030 
    oprot.writeFieldStop()
9031 
    oprot.writeStructEnd()
9032 
 
3431 rajveer 9033 
  def validate(self):
9034 
    return
9035 
 
9036 
 
94 ashish 9037 
  def __repr__(self):
9038 
    L = ['%s=%r' % (key, value)
9039 
      for key, value in self.__dict__.iteritems()]
9040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9041 
 
9042 
  def __eq__(self, other):
9043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9044 
 
9045 
  def __ne__(self, other):
9046 
    return not (self == other)
9047 
 
483 rajveer 9048 
class changeOrderStatus_result:
94 ashish 9049 
  """
9050 
  Attributes:
9051 
   - success
9052 
   - ex
9053 
  """
9054 
 
9055 
  thrift_spec = (
9056 
    (0, TType.BOOL, 'success', None, None, ), # 0
9057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9058 
  )
9059 
 
9060 
  def __init__(self, success=None, ex=None,):
9061 
    self.success = success
9062 
    self.ex = ex
9063 
 
9064 
  def read(self, iprot):
9065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9067 
      return
9068 
    iprot.readStructBegin()
9069 
    while True:
9070 
      (fname, ftype, fid) = iprot.readFieldBegin()
9071 
      if ftype == TType.STOP:
9072 
        break
9073 
      if fid == 0:
9074 
        if ftype == TType.BOOL:
9075 
          self.success = iprot.readBool();
9076 
        else:
9077 
          iprot.skip(ftype)
9078 
      elif fid == 1:
9079 
        if ftype == TType.STRUCT:
9080 
          self.ex = TransactionServiceException()
9081 
          self.ex.read(iprot)
9082 
        else:
9083 
          iprot.skip(ftype)
9084 
      else:
9085 
        iprot.skip(ftype)
9086 
      iprot.readFieldEnd()
9087 
    iprot.readStructEnd()
9088 
 
9089 
  def write(self, oprot):
9090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9092 
      return
483 rajveer 9093 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9094 
    if self.success is not None:
94 ashish 9095 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9096 
      oprot.writeBool(self.success)
9097 
      oprot.writeFieldEnd()
3431 rajveer 9098 
    if self.ex is not None:
94 ashish 9099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9100 
      self.ex.write(oprot)
9101 
      oprot.writeFieldEnd()
9102 
    oprot.writeFieldStop()
9103 
    oprot.writeStructEnd()
9104 
 
3431 rajveer 9105 
  def validate(self):
9106 
    return
9107 
 
9108 
 
94 ashish 9109 
  def __repr__(self):
9110 
    L = ['%s=%r' % (key, value)
9111 
      for key, value in self.__dict__.iteritems()]
9112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9113 
 
9114 
  def __eq__(self, other):
9115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9116 
 
9117 
  def __ne__(self, other):
9118 
    return not (self == other)
9119 
 
3064 chandransh 9120 
class getOrdersForTransaction_args:
494 rajveer 9121 
  """
9122 
  Attributes:
3064 chandransh 9123 
   - transactionId
9124 
   - customerId
494 rajveer 9125 
  """
9126 
 
9127 
  thrift_spec = (
9128 
    None, # 0
3064 chandransh 9129 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9130 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9131 
  )
9132 
 
3064 chandransh 9133 
  def __init__(self, transactionId=None, customerId=None,):
9134 
    self.transactionId = transactionId
9135 
    self.customerId = customerId
494 rajveer 9136 
 
9137 
  def read(self, iprot):
9138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9140 
      return
9141 
    iprot.readStructBegin()
9142 
    while True:
9143 
      (fname, ftype, fid) = iprot.readFieldBegin()
9144 
      if ftype == TType.STOP:
9145 
        break
9146 
      if fid == 1:
9147 
        if ftype == TType.I64:
3064 chandransh 9148 
          self.transactionId = iprot.readI64();
494 rajveer 9149 
        else:
9150 
          iprot.skip(ftype)
9151 
      elif fid == 2:
3064 chandransh 9152 
        if ftype == TType.I64:
9153 
          self.customerId = iprot.readI64();
494 rajveer 9154 
        else:
9155 
          iprot.skip(ftype)
9156 
      else:
9157 
        iprot.skip(ftype)
9158 
      iprot.readFieldEnd()
9159 
    iprot.readStructEnd()
9160 
 
9161 
  def write(self, oprot):
9162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9164 
      return
3064 chandransh 9165 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9166 
    if self.transactionId is not None:
3064 chandransh 9167 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9168 
      oprot.writeI64(self.transactionId)
494 rajveer 9169 
      oprot.writeFieldEnd()
3431 rajveer 9170 
    if self.customerId is not None:
3064 chandransh 9171 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9172 
      oprot.writeI64(self.customerId)
494 rajveer 9173 
      oprot.writeFieldEnd()
9174 
    oprot.writeFieldStop()
9175 
    oprot.writeStructEnd()
9176 
 
3431 rajveer 9177 
  def validate(self):
9178 
    return
9179 
 
9180 
 
494 rajveer 9181 
  def __repr__(self):
9182 
    L = ['%s=%r' % (key, value)
9183 
      for key, value in self.__dict__.iteritems()]
9184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9185 
 
9186 
  def __eq__(self, other):
9187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9188 
 
9189 
  def __ne__(self, other):
9190 
    return not (self == other)
9191 
 
3064 chandransh 9192 
class getOrdersForTransaction_result:
494 rajveer 9193 
  """
9194 
  Attributes:
9195 
   - success
9196 
   - ex
9197 
  """
9198 
 
9199 
  thrift_spec = (
3064 chandransh 9200 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9202 
  )
9203 
 
9204 
  def __init__(self, success=None, ex=None,):
9205 
    self.success = success
9206 
    self.ex = ex
9207 
 
9208 
  def read(self, iprot):
9209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9211 
      return
9212 
    iprot.readStructBegin()
9213 
    while True:
9214 
      (fname, ftype, fid) = iprot.readFieldBegin()
9215 
      if ftype == TType.STOP:
9216 
        break
9217 
      if fid == 0:
3064 chandransh 9218 
        if ftype == TType.LIST:
9219 
          self.success = []
5031 varun.gupt 9220 
          (_etype143, _size140) = iprot.readListBegin()
9221 
          for _i144 in xrange(_size140):
9222 
            _elem145 = Order()
9223 
            _elem145.read(iprot)
9224 
            self.success.append(_elem145)
3064 chandransh 9225 
          iprot.readListEnd()
494 rajveer 9226 
        else:
9227 
          iprot.skip(ftype)
9228 
      elif fid == 1:
9229 
        if ftype == TType.STRUCT:
9230 
          self.ex = TransactionServiceException()
9231 
          self.ex.read(iprot)
9232 
        else:
9233 
          iprot.skip(ftype)
9234 
      else:
9235 
        iprot.skip(ftype)
9236 
      iprot.readFieldEnd()
9237 
    iprot.readStructEnd()
9238 
 
9239 
  def write(self, oprot):
9240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9242 
      return
3064 chandransh 9243 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9244 
    if self.success is not None:
3064 chandransh 9245 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9246 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9247 
      for iter146 in self.success:
9248 
        iter146.write(oprot)
3064 chandransh 9249 
      oprot.writeListEnd()
494 rajveer 9250 
      oprot.writeFieldEnd()
3431 rajveer 9251 
    if self.ex is not None:
494 rajveer 9252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9253 
      self.ex.write(oprot)
9254 
      oprot.writeFieldEnd()
9255 
    oprot.writeFieldStop()
9256 
    oprot.writeStructEnd()
9257 
 
3431 rajveer 9258 
  def validate(self):
9259 
    return
9260 
 
9261 
 
494 rajveer 9262 
  def __repr__(self):
9263 
    L = ['%s=%r' % (key, value)
9264 
      for key, value in self.__dict__.iteritems()]
9265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9266 
 
9267 
  def __eq__(self, other):
9268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9269 
 
9270 
  def __ne__(self, other):
9271 
    return not (self == other)
9272 
 
3064 chandransh 9273 
class getOrdersForCustomer_args:
1149 chandransh 9274 
  """
9275 
  Attributes:
3064 chandransh 9276 
   - customerId
9277 
   - from_date
9278 
   - to_date
9279 
   - statuses
1149 chandransh 9280 
  """
9281 
 
9282 
  thrift_spec = (
9283 
    None, # 0
3064 chandransh 9284 
    (1, TType.I64, 'customerId', None, None, ), # 1
9285 
    (2, TType.I64, 'from_date', None, None, ), # 2
9286 
    (3, TType.I64, 'to_date', None, None, ), # 3
9287 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9288 
  )
9289 
 
3064 chandransh 9290 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9291 
    self.customerId = customerId
9292 
    self.from_date = from_date
9293 
    self.to_date = to_date
9294 
    self.statuses = statuses
1149 chandransh 9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 1:
9306 
        if ftype == TType.I64:
3064 chandransh 9307 
          self.customerId = iprot.readI64();
1149 chandransh 9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 2:
9311 
        if ftype == TType.I64:
3064 chandransh 9312 
          self.from_date = iprot.readI64();
1149 chandransh 9313 
        else:
9314 
          iprot.skip(ftype)
2783 chandransh 9315 
      elif fid == 3:
9316 
        if ftype == TType.I64:
3064 chandransh 9317 
          self.to_date = iprot.readI64();
2783 chandransh 9318 
        else:
9319 
          iprot.skip(ftype)
9320 
      elif fid == 4:
3064 chandransh 9321 
        if ftype == TType.LIST:
9322 
          self.statuses = []
5031 varun.gupt 9323 
          (_etype150, _size147) = iprot.readListBegin()
9324 
          for _i151 in xrange(_size147):
9325 
            _elem152 = iprot.readI32();
9326 
            self.statuses.append(_elem152)
3064 chandransh 9327 
          iprot.readListEnd()
2783 chandransh 9328 
        else:
9329 
          iprot.skip(ftype)
1149 chandransh 9330 
      else:
9331 
        iprot.skip(ftype)
9332 
      iprot.readFieldEnd()
9333 
    iprot.readStructEnd()
9334 
 
9335 
  def write(self, oprot):
9336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9338 
      return
3064 chandransh 9339 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9340 
    if self.customerId is not None:
3064 chandransh 9341 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9342 
      oprot.writeI64(self.customerId)
1149 chandransh 9343 
      oprot.writeFieldEnd()
3431 rajveer 9344 
    if self.from_date is not None:
3064 chandransh 9345 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9346 
      oprot.writeI64(self.from_date)
1149 chandransh 9347 
      oprot.writeFieldEnd()
3431 rajveer 9348 
    if self.to_date is not None:
3064 chandransh 9349 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9350 
      oprot.writeI64(self.to_date)
2783 chandransh 9351 
      oprot.writeFieldEnd()
3431 rajveer 9352 
    if self.statuses is not None:
3064 chandransh 9353 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9354 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9355 
      for iter153 in self.statuses:
9356 
        oprot.writeI32(iter153)
3064 chandransh 9357 
      oprot.writeListEnd()
2783 chandransh 9358 
      oprot.writeFieldEnd()
1149 chandransh 9359 
    oprot.writeFieldStop()
9360 
    oprot.writeStructEnd()
9361 
 
3431 rajveer 9362 
  def validate(self):
9363 
    return
9364 
 
9365 
 
1149 chandransh 9366 
  def __repr__(self):
9367 
    L = ['%s=%r' % (key, value)
9368 
      for key, value in self.__dict__.iteritems()]
9369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9370 
 
9371 
  def __eq__(self, other):
9372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9373 
 
9374 
  def __ne__(self, other):
9375 
    return not (self == other)
9376 
 
3064 chandransh 9377 
class getOrdersForCustomer_result:
1149 chandransh 9378 
  """
9379 
  Attributes:
9380 
   - success
9381 
   - ex
9382 
  """
9383 
 
9384 
  thrift_spec = (
3064 chandransh 9385 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9387 
  )
9388 
 
9389 
  def __init__(self, success=None, ex=None,):
9390 
    self.success = success
9391 
    self.ex = ex
9392 
 
9393 
  def read(self, iprot):
9394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9396 
      return
9397 
    iprot.readStructBegin()
9398 
    while True:
9399 
      (fname, ftype, fid) = iprot.readFieldBegin()
9400 
      if ftype == TType.STOP:
9401 
        break
9402 
      if fid == 0:
3064 chandransh 9403 
        if ftype == TType.LIST:
9404 
          self.success = []
5031 varun.gupt 9405 
          (_etype157, _size154) = iprot.readListBegin()
9406 
          for _i158 in xrange(_size154):
9407 
            _elem159 = Order()
9408 
            _elem159.read(iprot)
9409 
            self.success.append(_elem159)
3064 chandransh 9410 
          iprot.readListEnd()
1149 chandransh 9411 
        else:
9412 
          iprot.skip(ftype)
9413 
      elif fid == 1:
9414 
        if ftype == TType.STRUCT:
9415 
          self.ex = TransactionServiceException()
9416 
          self.ex.read(iprot)
9417 
        else:
9418 
          iprot.skip(ftype)
9419 
      else:
9420 
        iprot.skip(ftype)
9421 
      iprot.readFieldEnd()
9422 
    iprot.readStructEnd()
9423 
 
9424 
  def write(self, oprot):
9425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9427 
      return
3064 chandransh 9428 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9429 
    if self.success is not None:
3064 chandransh 9430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9432 
      for iter160 in self.success:
9433 
        iter160.write(oprot)
3064 chandransh 9434 
      oprot.writeListEnd()
1149 chandransh 9435 
      oprot.writeFieldEnd()
3431 rajveer 9436 
    if self.ex is not None:
1149 chandransh 9437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9438 
      self.ex.write(oprot)
9439 
      oprot.writeFieldEnd()
9440 
    oprot.writeFieldStop()
9441 
    oprot.writeStructEnd()
9442 
 
3431 rajveer 9443 
  def validate(self):
9444 
    return
9445 
 
9446 
 
1149 chandransh 9447 
  def __repr__(self):
9448 
    L = ['%s=%r' % (key, value)
9449 
      for key, value in self.__dict__.iteritems()]
9450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9451 
 
9452 
  def __eq__(self, other):
9453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9454 
 
9455 
  def __ne__(self, other):
9456 
    return not (self == other)
9457 
 
3064 chandransh 9458 
class createOrder_args:
921 rajveer 9459 
  """
9460 
  Attributes:
3064 chandransh 9461 
   - order
921 rajveer 9462 
  """
9463 
 
9464 
  thrift_spec = (
9465 
    None, # 0
3064 chandransh 9466 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9467 
  )
9468 
 
3064 chandransh 9469 
  def __init__(self, order=None,):
9470 
    self.order = order
921 rajveer 9471 
 
9472 
  def read(self, iprot):
9473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9475 
      return
9476 
    iprot.readStructBegin()
9477 
    while True:
9478 
      (fname, ftype, fid) = iprot.readFieldBegin()
9479 
      if ftype == TType.STOP:
9480 
        break
9481 
      if fid == 1:
3064 chandransh 9482 
        if ftype == TType.STRUCT:
9483 
          self.order = Order()
9484 
          self.order.read(iprot)
921 rajveer 9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      else:
9488 
        iprot.skip(ftype)
9489 
      iprot.readFieldEnd()
9490 
    iprot.readStructEnd()
9491 
 
9492 
  def write(self, oprot):
9493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9495 
      return
3064 chandransh 9496 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9497 
    if self.order is not None:
3064 chandransh 9498 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9499 
      self.order.write(oprot)
921 rajveer 9500 
      oprot.writeFieldEnd()
9501 
    oprot.writeFieldStop()
9502 
    oprot.writeStructEnd()
9503 
 
3431 rajveer 9504 
  def validate(self):
9505 
    return
9506 
 
9507 
 
921 rajveer 9508 
  def __repr__(self):
9509 
    L = ['%s=%r' % (key, value)
9510 
      for key, value in self.__dict__.iteritems()]
9511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9512 
 
9513 
  def __eq__(self, other):
9514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9515 
 
9516 
  def __ne__(self, other):
9517 
    return not (self == other)
9518 
 
3064 chandransh 9519 
class createOrder_result:
921 rajveer 9520 
  """
9521 
  Attributes:
9522 
   - success
9523 
   - ex
9524 
  """
9525 
 
9526 
  thrift_spec = (
3064 chandransh 9527 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9529 
  )
9530 
 
9531 
  def __init__(self, success=None, ex=None,):
9532 
    self.success = success
9533 
    self.ex = ex
9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      if fid == 0:
3064 chandransh 9545 
        if ftype == TType.I64:
9546 
          self.success = iprot.readI64();
921 rajveer 9547 
        else:
9548 
          iprot.skip(ftype)
9549 
      elif fid == 1:
9550 
        if ftype == TType.STRUCT:
9551 
          self.ex = TransactionServiceException()
9552 
          self.ex.read(iprot)
9553 
        else:
9554 
          iprot.skip(ftype)
9555 
      else:
9556 
        iprot.skip(ftype)
9557 
      iprot.readFieldEnd()
9558 
    iprot.readStructEnd()
9559 
 
9560 
  def write(self, oprot):
9561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9563 
      return
3064 chandransh 9564 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9565 
    if self.success is not None:
3064 chandransh 9566 
      oprot.writeFieldBegin('success', TType.I64, 0)
9567 
      oprot.writeI64(self.success)
921 rajveer 9568 
      oprot.writeFieldEnd()
3431 rajveer 9569 
    if self.ex is not None:
921 rajveer 9570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9571 
      self.ex.write(oprot)
9572 
      oprot.writeFieldEnd()
9573 
    oprot.writeFieldStop()
9574 
    oprot.writeStructEnd()
9575 
 
3431 rajveer 9576 
  def validate(self):
9577 
    return
9578 
 
9579 
 
921 rajveer 9580 
  def __repr__(self):
9581 
    L = ['%s=%r' % (key, value)
9582 
      for key, value in self.__dict__.iteritems()]
9583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9584 
 
9585 
  def __eq__(self, other):
9586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9587 
 
9588 
  def __ne__(self, other):
9589 
    return not (self == other)
9590 
 
3064 chandransh 9591 
class getOrder_args:
921 rajveer 9592 
  """
9593 
  Attributes:
3064 chandransh 9594 
   - id
921 rajveer 9595 
  """
9596 
 
9597 
  thrift_spec = (
9598 
    None, # 0
3064 chandransh 9599 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9600 
  )
9601 
 
3064 chandransh 9602 
  def __init__(self, id=None,):
9603 
    self.id = id
921 rajveer 9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 1:
9615 
        if ftype == TType.I64:
3064 chandransh 9616 
          self.id = iprot.readI64();
921 rajveer 9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      else:
9620 
        iprot.skip(ftype)
9621 
      iprot.readFieldEnd()
9622 
    iprot.readStructEnd()
9623 
 
9624 
  def write(self, oprot):
9625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9627 
      return
3064 chandransh 9628 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9629 
    if self.id is not None:
3064 chandransh 9630 
      oprot.writeFieldBegin('id', TType.I64, 1)
9631 
      oprot.writeI64(self.id)
921 rajveer 9632 
      oprot.writeFieldEnd()
9633 
    oprot.writeFieldStop()
9634 
    oprot.writeStructEnd()
9635 
 
3431 rajveer 9636 
  def validate(self):
9637 
    return
9638 
 
9639 
 
921 rajveer 9640 
  def __repr__(self):
9641 
    L = ['%s=%r' % (key, value)
9642 
      for key, value in self.__dict__.iteritems()]
9643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9644 
 
9645 
  def __eq__(self, other):
9646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9647 
 
9648 
  def __ne__(self, other):
9649 
    return not (self == other)
9650 
 
3064 chandransh 9651 
class getOrder_result:
921 rajveer 9652 
  """
9653 
  Attributes:
9654 
   - success
9655 
   - ex
9656 
  """
9657 
 
9658 
  thrift_spec = (
3064 chandransh 9659 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9661 
  )
9662 
 
9663 
  def __init__(self, success=None, ex=None,):
9664 
    self.success = success
9665 
    self.ex = ex
9666 
 
9667 
  def read(self, iprot):
9668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9670 
      return
9671 
    iprot.readStructBegin()
9672 
    while True:
9673 
      (fname, ftype, fid) = iprot.readFieldBegin()
9674 
      if ftype == TType.STOP:
9675 
        break
9676 
      if fid == 0:
3064 chandransh 9677 
        if ftype == TType.STRUCT:
9678 
          self.success = Order()
9679 
          self.success.read(iprot)
921 rajveer 9680 
        else:
9681 
          iprot.skip(ftype)
9682 
      elif fid == 1:
9683 
        if ftype == TType.STRUCT:
9684 
          self.ex = TransactionServiceException()
9685 
          self.ex.read(iprot)
9686 
        else:
9687 
          iprot.skip(ftype)
9688 
      else:
9689 
        iprot.skip(ftype)
9690 
      iprot.readFieldEnd()
9691 
    iprot.readStructEnd()
9692 
 
9693 
  def write(self, oprot):
9694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9696 
      return
3064 chandransh 9697 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9698 
    if self.success is not None:
3064 chandransh 9699 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9700 
      self.success.write(oprot)
921 rajveer 9701 
      oprot.writeFieldEnd()
3431 rajveer 9702 
    if self.ex is not None:
921 rajveer 9703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9704 
      self.ex.write(oprot)
9705 
      oprot.writeFieldEnd()
9706 
    oprot.writeFieldStop()
9707 
    oprot.writeStructEnd()
9708 
 
3431 rajveer 9709 
  def validate(self):
9710 
    return
9711 
 
9712 
 
921 rajveer 9713 
  def __repr__(self):
9714 
    L = ['%s=%r' % (key, value)
9715 
      for key, value in self.__dict__.iteritems()]
9716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9717 
 
9718 
  def __eq__(self, other):
9719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9720 
 
9721 
  def __ne__(self, other):
9722 
    return not (self == other)
9723 
 
3064 chandransh 9724 
class getLineItemsForOrder_args:
94 ashish 9725 
  """
9726 
  Attributes:
3064 chandransh 9727 
   - orderId
94 ashish 9728 
  """
9729 
 
9730 
  thrift_spec = (
9731 
    None, # 0
3064 chandransh 9732 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9733 
  )
9734 
 
3064 chandransh 9735 
  def __init__(self, orderId=None,):
9736 
    self.orderId = orderId
94 ashish 9737 
 
9738 
  def read(self, iprot):
9739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9741 
      return
9742 
    iprot.readStructBegin()
9743 
    while True:
9744 
      (fname, ftype, fid) = iprot.readFieldBegin()
9745 
      if ftype == TType.STOP:
9746 
        break
9747 
      if fid == 1:
9748 
        if ftype == TType.I64:
3064 chandransh 9749 
          self.orderId = iprot.readI64();
94 ashish 9750 
        else:
9751 
          iprot.skip(ftype)
9752 
      else:
9753 
        iprot.skip(ftype)
9754 
      iprot.readFieldEnd()
9755 
    iprot.readStructEnd()
9756 
 
9757 
  def write(self, oprot):
9758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9760 
      return
3064 chandransh 9761 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9762 
    if self.orderId is not None:
3064 chandransh 9763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9764 
      oprot.writeI64(self.orderId)
94 ashish 9765 
      oprot.writeFieldEnd()
9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
3431 rajveer 9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
94 ashish 9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
3064 chandransh 9784 
class getLineItemsForOrder_result:
94 ashish 9785 
  """
9786 
  Attributes:
9787 
   - success
9788 
   - ex
9789 
  """
9790 
 
9791 
  thrift_spec = (
3064 chandransh 9792 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, success=None, ex=None,):
9797 
    self.success = success
9798 
    self.ex = ex
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 0:
483 rajveer 9810 
        if ftype == TType.LIST:
9811 
          self.success = []
5031 varun.gupt 9812 
          (_etype164, _size161) = iprot.readListBegin()
9813 
          for _i165 in xrange(_size161):
9814 
            _elem166 = LineItem()
9815 
            _elem166.read(iprot)
9816 
            self.success.append(_elem166)
483 rajveer 9817 
          iprot.readListEnd()
94 ashish 9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      elif fid == 1:
9821 
        if ftype == TType.STRUCT:
9822 
          self.ex = TransactionServiceException()
9823 
          self.ex.read(iprot)
9824 
        else:
9825 
          iprot.skip(ftype)
9826 
      else:
9827 
        iprot.skip(ftype)
9828 
      iprot.readFieldEnd()
9829 
    iprot.readStructEnd()
9830 
 
9831 
  def write(self, oprot):
9832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9834 
      return
3064 chandransh 9835 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9836 
    if self.success is not None:
483 rajveer 9837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9839 
      for iter167 in self.success:
9840 
        iter167.write(oprot)
483 rajveer 9841 
      oprot.writeListEnd()
94 ashish 9842 
      oprot.writeFieldEnd()
3431 rajveer 9843 
    if self.ex is not None:
94 ashish 9844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9845 
      self.ex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
3431 rajveer 9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
94 ashish 9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
4999 phani.kuma 9865 
class getOrderList_args:
9866 
  """
9867 
  Attributes:
9868 
   - order_ids
9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
9873 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9874 
  )
9875 
 
9876 
  def __init__(self, order_ids=None,):
9877 
    self.order_ids = order_ids
9878 
 
9879 
  def read(self, iprot):
9880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9882 
      return
9883 
    iprot.readStructBegin()
9884 
    while True:
9885 
      (fname, ftype, fid) = iprot.readFieldBegin()
9886 
      if ftype == TType.STOP:
9887 
        break
9888 
      if fid == 1:
9889 
        if ftype == TType.LIST:
9890 
          self.order_ids = []
5031 varun.gupt 9891 
          (_etype171, _size168) = iprot.readListBegin()
9892 
          for _i172 in xrange(_size168):
9893 
            _elem173 = iprot.readI64();
9894 
            self.order_ids.append(_elem173)
4999 phani.kuma 9895 
          iprot.readListEnd()
9896 
        else:
9897 
          iprot.skip(ftype)
9898 
      else:
9899 
        iprot.skip(ftype)
9900 
      iprot.readFieldEnd()
9901 
    iprot.readStructEnd()
9902 
 
9903 
  def write(self, oprot):
9904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9906 
      return
9907 
    oprot.writeStructBegin('getOrderList_args')
9908 
    if self.order_ids is not None:
9909 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9910 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9911 
      for iter174 in self.order_ids:
9912 
        oprot.writeI64(iter174)
4999 phani.kuma 9913 
      oprot.writeListEnd()
9914 
      oprot.writeFieldEnd()
9915 
    oprot.writeFieldStop()
9916 
    oprot.writeStructEnd()
9917 
 
9918 
  def validate(self):
9919 
    return
9920 
 
9921 
 
9922 
  def __repr__(self):
9923 
    L = ['%s=%r' % (key, value)
9924 
      for key, value in self.__dict__.iteritems()]
9925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9926 
 
9927 
  def __eq__(self, other):
9928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9929 
 
9930 
  def __ne__(self, other):
9931 
    return not (self == other)
9932 
 
9933 
class getOrderList_result:
9934 
  """
9935 
  Attributes:
9936 
   - success
9937 
  """
9938 
 
9939 
  thrift_spec = (
9940 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9941 
  )
9942 
 
9943 
  def __init__(self, success=None,):
9944 
    self.success = success
9945 
 
9946 
  def read(self, iprot):
9947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9949 
      return
9950 
    iprot.readStructBegin()
9951 
    while True:
9952 
      (fname, ftype, fid) = iprot.readFieldBegin()
9953 
      if ftype == TType.STOP:
9954 
        break
9955 
      if fid == 0:
9956 
        if ftype == TType.LIST:
9957 
          self.success = []
5031 varun.gupt 9958 
          (_etype178, _size175) = iprot.readListBegin()
9959 
          for _i179 in xrange(_size175):
9960 
            _elem180 = Order()
9961 
            _elem180.read(iprot)
9962 
            self.success.append(_elem180)
4999 phani.kuma 9963 
          iprot.readListEnd()
9964 
        else:
9965 
          iprot.skip(ftype)
9966 
      else:
9967 
        iprot.skip(ftype)
9968 
      iprot.readFieldEnd()
9969 
    iprot.readStructEnd()
9970 
 
9971 
  def write(self, oprot):
9972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9974 
      return
9975 
    oprot.writeStructBegin('getOrderList_result')
9976 
    if self.success is not None:
9977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9978 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9979 
      for iter181 in self.success:
9980 
        iter181.write(oprot)
4999 phani.kuma 9981 
      oprot.writeListEnd()
9982 
      oprot.writeFieldEnd()
9983 
    oprot.writeFieldStop()
9984 
    oprot.writeStructEnd()
9985 
 
9986 
  def validate(self):
9987 
    return
9988 
 
9989 
 
9990 
  def __repr__(self):
9991 
    L = ['%s=%r' % (key, value)
9992 
      for key, value in self.__dict__.iteritems()]
9993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9994 
 
9995 
  def __eq__(self, other):
9996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9997 
 
9998 
  def __ne__(self, other):
9999 
    return not (self == other)
10000 
 
5386 phani.kuma 10001 
class getOrderListForVendor_args:
10002 
  """
10003 
  Attributes:
10004 
   - order_ids
10005 
   - vendorId
10006 
  """
10007 
 
10008 
  thrift_spec = (
10009 
    None, # 0
10010 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10011 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10012 
  )
10013 
 
10014 
  def __init__(self, order_ids=None, vendorId=None,):
10015 
    self.order_ids = order_ids
10016 
    self.vendorId = vendorId
10017 
 
10018 
  def read(self, iprot):
10019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10021 
      return
10022 
    iprot.readStructBegin()
10023 
    while True:
10024 
      (fname, ftype, fid) = iprot.readFieldBegin()
10025 
      if ftype == TType.STOP:
10026 
        break
10027 
      if fid == 1:
10028 
        if ftype == TType.LIST:
10029 
          self.order_ids = []
10030 
          (_etype185, _size182) = iprot.readListBegin()
10031 
          for _i186 in xrange(_size182):
10032 
            _elem187 = iprot.readI64();
10033 
            self.order_ids.append(_elem187)
10034 
          iprot.readListEnd()
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      elif fid == 2:
10038 
        if ftype == TType.I64:
10039 
          self.vendorId = iprot.readI64();
10040 
        else:
10041 
          iprot.skip(ftype)
10042 
      else:
10043 
        iprot.skip(ftype)
10044 
      iprot.readFieldEnd()
10045 
    iprot.readStructEnd()
10046 
 
10047 
  def write(self, oprot):
10048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10050 
      return
10051 
    oprot.writeStructBegin('getOrderListForVendor_args')
10052 
    if self.order_ids is not None:
10053 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10054 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10055 
      for iter188 in self.order_ids:
10056 
        oprot.writeI64(iter188)
10057 
      oprot.writeListEnd()
10058 
      oprot.writeFieldEnd()
10059 
    if self.vendorId is not None:
10060 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10061 
      oprot.writeI64(self.vendorId)
10062 
      oprot.writeFieldEnd()
10063 
    oprot.writeFieldStop()
10064 
    oprot.writeStructEnd()
10065 
 
10066 
  def validate(self):
10067 
    return
10068 
 
10069 
 
10070 
  def __repr__(self):
10071 
    L = ['%s=%r' % (key, value)
10072 
      for key, value in self.__dict__.iteritems()]
10073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10074 
 
10075 
  def __eq__(self, other):
10076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10077 
 
10078 
  def __ne__(self, other):
10079 
    return not (self == other)
10080 
 
10081 
class getOrderListForVendor_result:
10082 
  """
10083 
  Attributes:
10084 
   - success
10085 
  """
10086 
 
10087 
  thrift_spec = (
10088 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10089 
  )
10090 
 
10091 
  def __init__(self, success=None,):
10092 
    self.success = success
10093 
 
10094 
  def read(self, iprot):
10095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10097 
      return
10098 
    iprot.readStructBegin()
10099 
    while True:
10100 
      (fname, ftype, fid) = iprot.readFieldBegin()
10101 
      if ftype == TType.STOP:
10102 
        break
10103 
      if fid == 0:
10104 
        if ftype == TType.LIST:
10105 
          self.success = []
10106 
          (_etype192, _size189) = iprot.readListBegin()
10107 
          for _i193 in xrange(_size189):
10108 
            _elem194 = Order()
10109 
            _elem194.read(iprot)
10110 
            self.success.append(_elem194)
10111 
          iprot.readListEnd()
10112 
        else:
10113 
          iprot.skip(ftype)
10114 
      else:
10115 
        iprot.skip(ftype)
10116 
      iprot.readFieldEnd()
10117 
    iprot.readStructEnd()
10118 
 
10119 
  def write(self, oprot):
10120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10122 
      return
10123 
    oprot.writeStructBegin('getOrderListForVendor_result')
10124 
    if self.success is not None:
10125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10127 
      for iter195 in self.success:
10128 
        iter195.write(oprot)
10129 
      oprot.writeListEnd()
10130 
      oprot.writeFieldEnd()
10131 
    oprot.writeFieldStop()
10132 
    oprot.writeStructEnd()
10133 
 
10134 
  def validate(self):
10135 
    return
10136 
 
10137 
 
10138 
  def __repr__(self):
10139 
    L = ['%s=%r' % (key, value)
10140 
      for key, value in self.__dict__.iteritems()]
10141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10142 
 
10143 
  def __eq__(self, other):
10144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10145 
 
10146 
  def __ne__(self, other):
10147 
    return not (self == other)
10148 
 
3064 chandransh 10149 
class getOrderForCustomer_args:
94 ashish 10150 
  """
10151 
  Attributes:
3064 chandransh 10152 
   - orderId
483 rajveer 10153 
   - customerId
94 ashish 10154 
  """
10155 
 
10156 
  thrift_spec = (
10157 
    None, # 0
3064 chandransh 10158 
    (1, TType.I64, 'orderId', None, None, ), # 1
10159 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10160 
  )
10161 
 
3064 chandransh 10162 
  def __init__(self, orderId=None, customerId=None,):
10163 
    self.orderId = orderId
483 rajveer 10164 
    self.customerId = customerId
94 ashish 10165 
 
10166 
  def read(self, iprot):
10167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10169 
      return
10170 
    iprot.readStructBegin()
10171 
    while True:
10172 
      (fname, ftype, fid) = iprot.readFieldBegin()
10173 
      if ftype == TType.STOP:
10174 
        break
10175 
      if fid == 1:
10176 
        if ftype == TType.I64:
3064 chandransh 10177 
          self.orderId = iprot.readI64();
94 ashish 10178 
        else:
10179 
          iprot.skip(ftype)
10180 
      elif fid == 2:
10181 
        if ftype == TType.I64:
3064 chandransh 10182 
          self.customerId = iprot.readI64();
94 ashish 10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      else:
10186 
        iprot.skip(ftype)
10187 
      iprot.readFieldEnd()
10188 
    iprot.readStructEnd()
10189 
 
10190 
  def write(self, oprot):
10191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10193 
      return
3064 chandransh 10194 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10195 
    if self.orderId is not None:
3064 chandransh 10196 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10197 
      oprot.writeI64(self.orderId)
10198 
      oprot.writeFieldEnd()
3431 rajveer 10199 
    if self.customerId is not None:
3064 chandransh 10200 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10201 
      oprot.writeI64(self.customerId)
94 ashish 10202 
      oprot.writeFieldEnd()
10203 
    oprot.writeFieldStop()
10204 
    oprot.writeStructEnd()
10205 
 
3431 rajveer 10206 
  def validate(self):
10207 
    return
10208 
 
10209 
 
94 ashish 10210 
  def __repr__(self):
10211 
    L = ['%s=%r' % (key, value)
10212 
      for key, value in self.__dict__.iteritems()]
10213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10214 
 
10215 
  def __eq__(self, other):
10216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10217 
 
10218 
  def __ne__(self, other):
10219 
    return not (self == other)
10220 
 
3064 chandransh 10221 
class getOrderForCustomer_result:
94 ashish 10222 
  """
10223 
  Attributes:
10224 
   - success
10225 
   - ex
10226 
  """
10227 
 
10228 
  thrift_spec = (
3064 chandransh 10229 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10231 
  )
10232 
 
10233 
  def __init__(self, success=None, ex=None,):
10234 
    self.success = success
10235 
    self.ex = ex
10236 
 
10237 
  def read(self, iprot):
10238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10240 
      return
10241 
    iprot.readStructBegin()
10242 
    while True:
10243 
      (fname, ftype, fid) = iprot.readFieldBegin()
10244 
      if ftype == TType.STOP:
10245 
        break
10246 
      if fid == 0:
3064 chandransh 10247 
        if ftype == TType.STRUCT:
10248 
          self.success = Order()
10249 
          self.success.read(iprot)
94 ashish 10250 
        else:
10251 
          iprot.skip(ftype)
10252 
      elif fid == 1:
10253 
        if ftype == TType.STRUCT:
10254 
          self.ex = TransactionServiceException()
10255 
          self.ex.read(iprot)
10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      else:
10259 
        iprot.skip(ftype)
10260 
      iprot.readFieldEnd()
10261 
    iprot.readStructEnd()
10262 
 
10263 
  def write(self, oprot):
10264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10266 
      return
3064 chandransh 10267 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10268 
    if self.success is not None:
3064 chandransh 10269 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10270 
      self.success.write(oprot)
94 ashish 10271 
      oprot.writeFieldEnd()
3431 rajveer 10272 
    if self.ex is not None:
94 ashish 10273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10274 
      self.ex.write(oprot)
10275 
      oprot.writeFieldEnd()
10276 
    oprot.writeFieldStop()
10277 
    oprot.writeStructEnd()
10278 
 
3431 rajveer 10279 
  def validate(self):
10280 
    return
10281 
 
10282 
 
94 ashish 10283 
  def __repr__(self):
10284 
    L = ['%s=%r' % (key, value)
10285 
      for key, value in self.__dict__.iteritems()]
10286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10287 
 
10288 
  def __eq__(self, other):
10289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10290 
 
10291 
  def __ne__(self, other):
10292 
    return not (self == other)
10293 
 
3064 chandransh 10294 
class getAlerts_args:
94 ashish 10295 
  """
10296 
  Attributes:
4394 rajveer 10297 
   - type
4444 rajveer 10298 
   - warehouseId
4394 rajveer 10299 
   - status
10300 
   - timestamp
94 ashish 10301 
  """
10302 
 
10303 
  thrift_spec = (
10304 
    None, # 0
4394 rajveer 10305 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10306 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10307 
    (3, TType.I64, 'status', None, None, ), # 3
10308 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10309 
  )
10310 
 
4444 rajveer 10311 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10312 
    self.type = type
4444 rajveer 10313 
    self.warehouseId = warehouseId
4394 rajveer 10314 
    self.status = status
10315 
    self.timestamp = timestamp
94 ashish 10316 
 
10317 
  def read(self, iprot):
10318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10320 
      return
10321 
    iprot.readStructBegin()
10322 
    while True:
10323 
      (fname, ftype, fid) = iprot.readFieldBegin()
10324 
      if ftype == TType.STOP:
10325 
        break
10326 
      if fid == 1:
3064 chandransh 10327 
        if ftype == TType.I64:
4394 rajveer 10328 
          self.type = iprot.readI64();
94 ashish 10329 
        else:
10330 
          iprot.skip(ftype)
3064 chandransh 10331 
      elif fid == 2:
4394 rajveer 10332 
        if ftype == TType.I64:
4444 rajveer 10333 
          self.warehouseId = iprot.readI64();
3064 chandransh 10334 
        else:
10335 
          iprot.skip(ftype)
4394 rajveer 10336 
      elif fid == 3:
10337 
        if ftype == TType.I64:
4444 rajveer 10338 
          self.status = iprot.readI64();
10339 
        else:
10340 
          iprot.skip(ftype)
10341 
      elif fid == 4:
10342 
        if ftype == TType.I64:
4394 rajveer 10343 
          self.timestamp = iprot.readI64();
10344 
        else:
10345 
          iprot.skip(ftype)
94 ashish 10346 
      else:
10347 
        iprot.skip(ftype)
10348 
      iprot.readFieldEnd()
10349 
    iprot.readStructEnd()
10350 
 
10351 
  def write(self, oprot):
10352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10354 
      return
3064 chandransh 10355 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10356 
    if self.type is not None:
10357 
      oprot.writeFieldBegin('type', TType.I64, 1)
10358 
      oprot.writeI64(self.type)
94 ashish 10359 
      oprot.writeFieldEnd()
4444 rajveer 10360 
    if self.warehouseId is not None:
10361 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10362 
      oprot.writeI64(self.warehouseId)
10363 
      oprot.writeFieldEnd()
4394 rajveer 10364 
    if self.status is not None:
4444 rajveer 10365 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10366 
      oprot.writeI64(self.status)
3064 chandransh 10367 
      oprot.writeFieldEnd()
4394 rajveer 10368 
    if self.timestamp is not None:
4444 rajveer 10369 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10370 
      oprot.writeI64(self.timestamp)
10371 
      oprot.writeFieldEnd()
94 ashish 10372 
    oprot.writeFieldStop()
10373 
    oprot.writeStructEnd()
10374 
 
3431 rajveer 10375 
  def validate(self):
10376 
    return
10377 
 
10378 
 
94 ashish 10379 
  def __repr__(self):
10380 
    L = ['%s=%r' % (key, value)
10381 
      for key, value in self.__dict__.iteritems()]
10382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10383 
 
10384 
  def __eq__(self, other):
10385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10386 
 
10387 
  def __ne__(self, other):
10388 
    return not (self == other)
10389 
 
3064 chandransh 10390 
class getAlerts_result:
94 ashish 10391 
  """
10392 
  Attributes:
10393 
   - success
10394 
  """
10395 
 
10396 
  thrift_spec = (
3064 chandransh 10397 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10398 
  )
10399 
 
3064 chandransh 10400 
  def __init__(self, success=None,):
94 ashish 10401 
    self.success = success
10402 
 
10403 
  def read(self, iprot):
10404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10406 
      return
10407 
    iprot.readStructBegin()
10408 
    while True:
10409 
      (fname, ftype, fid) = iprot.readFieldBegin()
10410 
      if ftype == TType.STOP:
10411 
        break
10412 
      if fid == 0:
3064 chandransh 10413 
        if ftype == TType.LIST:
10414 
          self.success = []
5386 phani.kuma 10415 
          (_etype199, _size196) = iprot.readListBegin()
10416 
          for _i200 in xrange(_size196):
10417 
            _elem201 = Alert()
10418 
            _elem201.read(iprot)
10419 
            self.success.append(_elem201)
3064 chandransh 10420 
          iprot.readListEnd()
94 ashish 10421 
        else:
10422 
          iprot.skip(ftype)
10423 
      else:
10424 
        iprot.skip(ftype)
10425 
      iprot.readFieldEnd()
10426 
    iprot.readStructEnd()
10427 
 
10428 
  def write(self, oprot):
10429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10431 
      return
3064 chandransh 10432 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10433 
    if self.success is not None:
3064 chandransh 10434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10436 
      for iter202 in self.success:
10437 
        iter202.write(oprot)
3064 chandransh 10438 
      oprot.writeListEnd()
94 ashish 10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
3431 rajveer 10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
94 ashish 10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
4394 rajveer 10458 
class addAlert_args:
94 ashish 10459 
  """
10460 
  Attributes:
3064 chandransh 10461 
   - type
4444 rajveer 10462 
   - warehouseId
4394 rajveer 10463 
   - description
94 ashish 10464 
  """
10465 
 
10466 
  thrift_spec = (
10467 
    None, # 0
4394 rajveer 10468 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10469 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10470 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10471 
  )
10472 
 
4444 rajveer 10473 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10474 
    self.type = type
4444 rajveer 10475 
    self.warehouseId = warehouseId
4394 rajveer 10476 
    self.description = description
94 ashish 10477 
 
10478 
  def read(self, iprot):
10479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10481 
      return
10482 
    iprot.readStructBegin()
10483 
    while True:
10484 
      (fname, ftype, fid) = iprot.readFieldBegin()
10485 
      if ftype == TType.STOP:
10486 
        break
10487 
      if fid == 1:
10488 
        if ftype == TType.I64:
4394 rajveer 10489 
          self.type = iprot.readI64();
94 ashish 10490 
        else:
10491 
          iprot.skip(ftype)
3064 chandransh 10492 
      elif fid == 2:
4444 rajveer 10493 
        if ftype == TType.I64:
10494 
          self.warehouseId = iprot.readI64();
10495 
        else:
10496 
          iprot.skip(ftype)
10497 
      elif fid == 3:
3064 chandransh 10498 
        if ftype == TType.STRING:
4394 rajveer 10499 
          self.description = iprot.readString();
3064 chandransh 10500 
        else:
10501 
          iprot.skip(ftype)
94 ashish 10502 
      else:
10503 
        iprot.skip(ftype)
10504 
      iprot.readFieldEnd()
10505 
    iprot.readStructEnd()
10506 
 
10507 
  def write(self, oprot):
10508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10510 
      return
4394 rajveer 10511 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10512 
    if self.type is not None:
4394 rajveer 10513 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10514 
      oprot.writeI64(self.type)
10515 
      oprot.writeFieldEnd()
4444 rajveer 10516 
    if self.warehouseId is not None:
10517 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10518 
      oprot.writeI64(self.warehouseId)
10519 
      oprot.writeFieldEnd()
4394 rajveer 10520 
    if self.description is not None:
4444 rajveer 10521 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10522 
      oprot.writeString(self.description)
3064 chandransh 10523 
      oprot.writeFieldEnd()
94 ashish 10524 
    oprot.writeFieldStop()
10525 
    oprot.writeStructEnd()
10526 
 
3431 rajveer 10527 
  def validate(self):
10528 
    return
10529 
 
10530 
 
94 ashish 10531 
  def __repr__(self):
10532 
    L = ['%s=%r' % (key, value)
10533 
      for key, value in self.__dict__.iteritems()]
10534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10535 
 
10536 
  def __eq__(self, other):
10537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10538 
 
10539 
  def __ne__(self, other):
10540 
    return not (self == other)
10541 
 
4394 rajveer 10542 
class addAlert_result:
3064 chandransh 10543 
 
10544 
  thrift_spec = (
10545 
  )
10546 
 
10547 
  def read(self, iprot):
10548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10550 
      return
10551 
    iprot.readStructBegin()
10552 
    while True:
10553 
      (fname, ftype, fid) = iprot.readFieldBegin()
10554 
      if ftype == TType.STOP:
10555 
        break
10556 
      else:
10557 
        iprot.skip(ftype)
10558 
      iprot.readFieldEnd()
10559 
    iprot.readStructEnd()
10560 
 
10561 
  def write(self, oprot):
10562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10564 
      return
4394 rajveer 10565 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
3431 rajveer 10569 
  def validate(self):
10570 
    return
10571 
 
10572 
 
3064 chandransh 10573 
  def __repr__(self):
10574 
    L = ['%s=%r' % (key, value)
10575 
      for key, value in self.__dict__.iteritems()]
10576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10577 
 
10578 
  def __eq__(self, other):
10579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10580 
 
10581 
  def __ne__(self, other):
10582 
    return not (self == other)
10583 
 
4444 rajveer 10584 
class markAlertsAsSeen_args:
10585 
  """
10586 
  Attributes:
10587 
   - warehouseId
10588 
  """
10589 
 
10590 
  thrift_spec = (
10591 
    None, # 0
10592 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10593 
  )
10594 
 
10595 
  def __init__(self, warehouseId=None,):
10596 
    self.warehouseId = warehouseId
10597 
 
10598 
  def read(self, iprot):
10599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10601 
      return
10602 
    iprot.readStructBegin()
10603 
    while True:
10604 
      (fname, ftype, fid) = iprot.readFieldBegin()
10605 
      if ftype == TType.STOP:
10606 
        break
10607 
      if fid == 1:
10608 
        if ftype == TType.I64:
10609 
          self.warehouseId = iprot.readI64();
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      else:
10613 
        iprot.skip(ftype)
10614 
      iprot.readFieldEnd()
10615 
    iprot.readStructEnd()
10616 
 
10617 
  def write(self, oprot):
10618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10620 
      return
10621 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10622 
    if self.warehouseId is not None:
10623 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10624 
      oprot.writeI64(self.warehouseId)
10625 
      oprot.writeFieldEnd()
10626 
    oprot.writeFieldStop()
10627 
    oprot.writeStructEnd()
10628 
 
10629 
  def validate(self):
10630 
    return
10631 
 
10632 
 
10633 
  def __repr__(self):
10634 
    L = ['%s=%r' % (key, value)
10635 
      for key, value in self.__dict__.iteritems()]
10636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10637 
 
10638 
  def __eq__(self, other):
10639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10640 
 
10641 
  def __ne__(self, other):
10642 
    return not (self == other)
10643 
 
10644 
class markAlertsAsSeen_result:
10645 
 
10646 
  thrift_spec = (
10647 
  )
10648 
 
10649 
  def read(self, iprot):
10650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10652 
      return
10653 
    iprot.readStructBegin()
10654 
    while True:
10655 
      (fname, ftype, fid) = iprot.readFieldBegin()
10656 
      if ftype == TType.STOP:
10657 
        break
10658 
      else:
10659 
        iprot.skip(ftype)
10660 
      iprot.readFieldEnd()
10661 
    iprot.readStructEnd()
10662 
 
10663 
  def write(self, oprot):
10664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10666 
      return
10667 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10668 
    oprot.writeFieldStop()
10669 
    oprot.writeStructEnd()
10670 
 
10671 
  def validate(self):
10672 
    return
10673 
 
10674 
 
10675 
  def __repr__(self):
10676 
    L = ['%s=%r' % (key, value)
10677 
      for key, value in self.__dict__.iteritems()]
10678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10679 
 
10680 
  def __eq__(self, other):
10681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10682 
 
10683 
  def __ne__(self, other):
10684 
    return not (self == other)
10685 
 
3064 chandransh 10686 
class getValidOrderCount_args:
10687 
 
10688 
  thrift_spec = (
10689 
  )
10690 
 
10691 
  def read(self, iprot):
10692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10694 
      return
10695 
    iprot.readStructBegin()
10696 
    while True:
10697 
      (fname, ftype, fid) = iprot.readFieldBegin()
10698 
      if ftype == TType.STOP:
10699 
        break
10700 
      else:
10701 
        iprot.skip(ftype)
10702 
      iprot.readFieldEnd()
10703 
    iprot.readStructEnd()
10704 
 
10705 
  def write(self, oprot):
10706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10708 
      return
10709 
    oprot.writeStructBegin('getValidOrderCount_args')
10710 
    oprot.writeFieldStop()
10711 
    oprot.writeStructEnd()
10712 
 
3431 rajveer 10713 
  def validate(self):
10714 
    return
10715 
 
10716 
 
3064 chandransh 10717 
  def __repr__(self):
10718 
    L = ['%s=%r' % (key, value)
10719 
      for key, value in self.__dict__.iteritems()]
10720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10721 
 
10722 
  def __eq__(self, other):
10723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10724 
 
10725 
  def __ne__(self, other):
10726 
    return not (self == other)
10727 
 
10728 
class getValidOrderCount_result:
94 ashish 10729 
  """
10730 
  Attributes:
10731 
   - success
10732 
  """
10733 
 
10734 
  thrift_spec = (
3064 chandransh 10735 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10736 
  )
10737 
 
3064 chandransh 10738 
  def __init__(self, success=None,):
94 ashish 10739 
    self.success = success
10740 
 
10741 
  def read(self, iprot):
10742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10744 
      return
10745 
    iprot.readStructBegin()
10746 
    while True:
10747 
      (fname, ftype, fid) = iprot.readFieldBegin()
10748 
      if ftype == TType.STOP:
10749 
        break
10750 
      if fid == 0:
3064 chandransh 10751 
        if ftype == TType.I64:
10752 
          self.success = iprot.readI64();
94 ashish 10753 
        else:
10754 
          iprot.skip(ftype)
10755 
      else:
10756 
        iprot.skip(ftype)
10757 
      iprot.readFieldEnd()
10758 
    iprot.readStructEnd()
10759 
 
10760 
  def write(self, oprot):
10761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10763 
      return
3064 chandransh 10764 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10765 
    if self.success is not None:
3064 chandransh 10766 
      oprot.writeFieldBegin('success', TType.I64, 0)
10767 
      oprot.writeI64(self.success)
94 ashish 10768 
      oprot.writeFieldEnd()
10769 
    oprot.writeFieldStop()
10770 
    oprot.writeStructEnd()
10771 
 
3431 rajveer 10772 
  def validate(self):
10773 
    return
10774 
 
10775 
 
94 ashish 10776 
  def __repr__(self):
10777 
    L = ['%s=%r' % (key, value)
10778 
      for key, value in self.__dict__.iteritems()]
10779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10780 
 
10781 
  def __eq__(self, other):
10782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10783 
 
10784 
  def __ne__(self, other):
10785 
    return not (self == other)
10786 
 
3064 chandransh 10787 
class getNoOfCustomersWithSuccessfulTransaction_args:
10788 
 
10789 
  thrift_spec = (
10790 
  )
10791 
 
10792 
  def read(self, iprot):
10793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10795 
      return
10796 
    iprot.readStructBegin()
10797 
    while True:
10798 
      (fname, ftype, fid) = iprot.readFieldBegin()
10799 
      if ftype == TType.STOP:
10800 
        break
10801 
      else:
10802 
        iprot.skip(ftype)
10803 
      iprot.readFieldEnd()
10804 
    iprot.readStructEnd()
10805 
 
10806 
  def write(self, oprot):
10807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10809 
      return
10810 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10811 
    oprot.writeFieldStop()
10812 
    oprot.writeStructEnd()
10813 
 
3431 rajveer 10814 
  def validate(self):
10815 
    return
10816 
 
10817 
 
3064 chandransh 10818 
  def __repr__(self):
10819 
    L = ['%s=%r' % (key, value)
10820 
      for key, value in self.__dict__.iteritems()]
10821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10822 
 
10823 
  def __eq__(self, other):
10824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10825 
 
10826 
  def __ne__(self, other):
10827 
    return not (self == other)
10828 
 
10829 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10830 
  """
10831 
  Attributes:
3064 chandransh 10832 
   - success
94 ashish 10833 
  """
10834 
 
10835 
  thrift_spec = (
3064 chandransh 10836 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10837 
  )
10838 
 
3064 chandransh 10839 
  def __init__(self, success=None,):
10840 
    self.success = success
94 ashish 10841 
 
10842 
  def read(self, iprot):
10843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10845 
      return
10846 
    iprot.readStructBegin()
10847 
    while True:
10848 
      (fname, ftype, fid) = iprot.readFieldBegin()
10849 
      if ftype == TType.STOP:
10850 
        break
3064 chandransh 10851 
      if fid == 0:
94 ashish 10852 
        if ftype == TType.I64:
3064 chandransh 10853 
          self.success = iprot.readI64();
94 ashish 10854 
        else:
10855 
          iprot.skip(ftype)
10856 
      else:
10857 
        iprot.skip(ftype)
10858 
      iprot.readFieldEnd()
10859 
    iprot.readStructEnd()
10860 
 
10861 
  def write(self, oprot):
10862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10864 
      return
3064 chandransh 10865 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10866 
    if self.success is not None:
3064 chandransh 10867 
      oprot.writeFieldBegin('success', TType.I64, 0)
10868 
      oprot.writeI64(self.success)
94 ashish 10869 
      oprot.writeFieldEnd()
10870 
    oprot.writeFieldStop()
10871 
    oprot.writeStructEnd()
10872 
 
3431 rajveer 10873 
  def validate(self):
10874 
    return
10875 
 
10876 
 
94 ashish 10877 
  def __repr__(self):
10878 
    L = ['%s=%r' % (key, value)
10879 
      for key, value in self.__dict__.iteritems()]
10880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10881 
 
10882 
  def __eq__(self, other):
10883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10884 
 
10885 
  def __ne__(self, other):
10886 
    return not (self == other)
10887 
 
3064 chandransh 10888 
class getValidOrdersAmountRange_args:
10889 
 
10890 
  thrift_spec = (
10891 
  )
10892 
 
10893 
  def read(self, iprot):
10894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10896 
      return
10897 
    iprot.readStructBegin()
10898 
    while True:
10899 
      (fname, ftype, fid) = iprot.readFieldBegin()
10900 
      if ftype == TType.STOP:
10901 
        break
10902 
      else:
10903 
        iprot.skip(ftype)
10904 
      iprot.readFieldEnd()
10905 
    iprot.readStructEnd()
10906 
 
10907 
  def write(self, oprot):
10908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10910 
      return
10911 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10912 
    oprot.writeFieldStop()
10913 
    oprot.writeStructEnd()
10914 
 
3431 rajveer 10915 
  def validate(self):
10916 
    return
10917 
 
10918 
 
3064 chandransh 10919 
  def __repr__(self):
10920 
    L = ['%s=%r' % (key, value)
10921 
      for key, value in self.__dict__.iteritems()]
10922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10923 
 
10924 
  def __eq__(self, other):
10925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10926 
 
10927 
  def __ne__(self, other):
10928 
    return not (self == other)
10929 
 
10930 
class getValidOrdersAmountRange_result:
94 ashish 10931 
  """
10932 
  Attributes:
10933 
   - success
10934 
  """
10935 
 
10936 
  thrift_spec = (
3064 chandransh 10937 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10938 
  )
10939 
 
3064 chandransh 10940 
  def __init__(self, success=None,):
94 ashish 10941 
    self.success = success
10942 
 
10943 
  def read(self, iprot):
10944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10946 
      return
10947 
    iprot.readStructBegin()
10948 
    while True:
10949 
      (fname, ftype, fid) = iprot.readFieldBegin()
10950 
      if ftype == TType.STOP:
10951 
        break
10952 
      if fid == 0:
483 rajveer 10953 
        if ftype == TType.LIST:
10954 
          self.success = []
5386 phani.kuma 10955 
          (_etype206, _size203) = iprot.readListBegin()
10956 
          for _i207 in xrange(_size203):
10957 
            _elem208 = iprot.readDouble();
10958 
            self.success.append(_elem208)
483 rajveer 10959 
          iprot.readListEnd()
94 ashish 10960 
        else:
10961 
          iprot.skip(ftype)
10962 
      else:
10963 
        iprot.skip(ftype)
10964 
      iprot.readFieldEnd()
10965 
    iprot.readStructEnd()
10966 
 
10967 
  def write(self, oprot):
10968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10970 
      return
3064 chandransh 10971 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10972 
    if self.success is not None:
483 rajveer 10973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10974 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 10975 
      for iter209 in self.success:
10976 
        oprot.writeDouble(iter209)
483 rajveer 10977 
      oprot.writeListEnd()
94 ashish 10978 
      oprot.writeFieldEnd()
10979 
    oprot.writeFieldStop()
10980 
    oprot.writeStructEnd()
10981 
 
3431 rajveer 10982 
  def validate(self):
10983 
    return
10984 
 
10985 
 
94 ashish 10986 
  def __repr__(self):
10987 
    L = ['%s=%r' % (key, value)
10988 
      for key, value in self.__dict__.iteritems()]
10989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10990 
 
10991 
  def __eq__(self, other):
10992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10993 
 
10994 
  def __ne__(self, other):
10995 
    return not (self == other)
10996 
 
3064 chandransh 10997 
class getValidOrders_args:
1528 ankur.sing 10998 
  """
10999 
  Attributes:
3064 chandransh 11000 
   - limit
1528 ankur.sing 11001 
  """
11002 
 
11003 
  thrift_spec = (
11004 
    None, # 0
3064 chandransh 11005 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11006 
  )
11007 
 
3064 chandransh 11008 
  def __init__(self, limit=None,):
11009 
    self.limit = limit
1528 ankur.sing 11010 
 
11011 
  def read(self, iprot):
11012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11014 
      return
11015 
    iprot.readStructBegin()
11016 
    while True:
11017 
      (fname, ftype, fid) = iprot.readFieldBegin()
11018 
      if ftype == TType.STOP:
11019 
        break
11020 
      if fid == 1:
11021 
        if ftype == TType.I64:
3064 chandransh 11022 
          self.limit = iprot.readI64();
1528 ankur.sing 11023 
        else:
11024 
          iprot.skip(ftype)
11025 
      else:
11026 
        iprot.skip(ftype)
11027 
      iprot.readFieldEnd()
11028 
    iprot.readStructEnd()
11029 
 
11030 
  def write(self, oprot):
11031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11033 
      return
3064 chandransh 11034 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11035 
    if self.limit is not None:
3064 chandransh 11036 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11037 
      oprot.writeI64(self.limit)
1528 ankur.sing 11038 
      oprot.writeFieldEnd()
11039 
    oprot.writeFieldStop()
11040 
    oprot.writeStructEnd()
11041 
 
3431 rajveer 11042 
  def validate(self):
11043 
    return
11044 
 
11045 
 
1528 ankur.sing 11046 
  def __repr__(self):
11047 
    L = ['%s=%r' % (key, value)
11048 
      for key, value in self.__dict__.iteritems()]
11049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11050 
 
11051 
  def __eq__(self, other):
11052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11053 
 
11054 
  def __ne__(self, other):
11055 
    return not (self == other)
11056 
 
3064 chandransh 11057 
class getValidOrders_result:
1528 ankur.sing 11058 
  """
11059 
  Attributes:
11060 
   - success
11061 
  """
11062 
 
11063 
  thrift_spec = (
3064 chandransh 11064 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11065 
  )
11066 
 
3064 chandransh 11067 
  def __init__(self, success=None,):
1528 ankur.sing 11068 
    self.success = success
11069 
 
11070 
  def read(self, iprot):
11071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11073 
      return
11074 
    iprot.readStructBegin()
11075 
    while True:
11076 
      (fname, ftype, fid) = iprot.readFieldBegin()
11077 
      if ftype == TType.STOP:
11078 
        break
11079 
      if fid == 0:
3064 chandransh 11080 
        if ftype == TType.LIST:
11081 
          self.success = []
5386 phani.kuma 11082 
          (_etype213, _size210) = iprot.readListBegin()
11083 
          for _i214 in xrange(_size210):
11084 
            _elem215 = Order()
11085 
            _elem215.read(iprot)
11086 
            self.success.append(_elem215)
3064 chandransh 11087 
          iprot.readListEnd()
1528 ankur.sing 11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      else:
11091 
        iprot.skip(ftype)
11092 
      iprot.readFieldEnd()
11093 
    iprot.readStructEnd()
11094 
 
11095 
  def write(self, oprot):
11096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11098 
      return
3064 chandransh 11099 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11100 
    if self.success is not None:
3064 chandransh 11101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11102 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11103 
      for iter216 in self.success:
11104 
        iter216.write(oprot)
3064 chandransh 11105 
      oprot.writeListEnd()
1528 ankur.sing 11106 
      oprot.writeFieldEnd()
11107 
    oprot.writeFieldStop()
11108 
    oprot.writeStructEnd()
11109 
 
3431 rajveer 11110 
  def validate(self):
11111 
    return
11112 
 
11113 
 
1528 ankur.sing 11114 
  def __repr__(self):
11115 
    L = ['%s=%r' % (key, value)
11116 
      for key, value in self.__dict__.iteritems()]
11117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11118 
 
11119 
  def __eq__(self, other):
11120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11121 
 
11122 
  def __ne__(self, other):
11123 
    return not (self == other)
11124 
 
1220 chandransh 11125 
class batchOrders_args:
11126 
  """
11127 
  Attributes:
11128 
   - warehouseId
11129 
  """
11130 
 
11131 
  thrift_spec = (
11132 
    None, # 0
11133 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11134 
  )
11135 
 
11136 
  def __init__(self, warehouseId=None,):
11137 
    self.warehouseId = warehouseId
11138 
 
11139 
  def read(self, iprot):
11140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11142 
      return
11143 
    iprot.readStructBegin()
11144 
    while True:
11145 
      (fname, ftype, fid) = iprot.readFieldBegin()
11146 
      if ftype == TType.STOP:
11147 
        break
11148 
      if fid == 1:
11149 
        if ftype == TType.I64:
11150 
          self.warehouseId = iprot.readI64();
11151 
        else:
11152 
          iprot.skip(ftype)
11153 
      else:
11154 
        iprot.skip(ftype)
11155 
      iprot.readFieldEnd()
11156 
    iprot.readStructEnd()
11157 
 
11158 
  def write(self, oprot):
11159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11161 
      return
11162 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11163 
    if self.warehouseId is not None:
1220 chandransh 11164 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11165 
      oprot.writeI64(self.warehouseId)
11166 
      oprot.writeFieldEnd()
11167 
    oprot.writeFieldStop()
11168 
    oprot.writeStructEnd()
11169 
 
3431 rajveer 11170 
  def validate(self):
11171 
    return
11172 
 
11173 
 
1220 chandransh 11174 
  def __repr__(self):
11175 
    L = ['%s=%r' % (key, value)
11176 
      for key, value in self.__dict__.iteritems()]
11177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11178 
 
11179 
  def __eq__(self, other):
11180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11181 
 
11182 
  def __ne__(self, other):
11183 
    return not (self == other)
11184 
 
11185 
class batchOrders_result:
11186 
  """
11187 
  Attributes:
11188 
   - success
11189 
   - ex
11190 
  """
11191 
 
11192 
  thrift_spec = (
11193 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11195 
  )
11196 
 
11197 
  def __init__(self, success=None, ex=None,):
11198 
    self.success = success
11199 
    self.ex = ex
11200 
 
11201 
  def read(self, iprot):
11202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11204 
      return
11205 
    iprot.readStructBegin()
11206 
    while True:
11207 
      (fname, ftype, fid) = iprot.readFieldBegin()
11208 
      if ftype == TType.STOP:
11209 
        break
11210 
      if fid == 0:
11211 
        if ftype == TType.LIST:
11212 
          self.success = []
5386 phani.kuma 11213 
          (_etype220, _size217) = iprot.readListBegin()
11214 
          for _i221 in xrange(_size217):
11215 
            _elem222 = Order()
11216 
            _elem222.read(iprot)
11217 
            self.success.append(_elem222)
1220 chandransh 11218 
          iprot.readListEnd()
11219 
        else:
11220 
          iprot.skip(ftype)
11221 
      elif fid == 1:
11222 
        if ftype == TType.STRUCT:
11223 
          self.ex = TransactionServiceException()
11224 
          self.ex.read(iprot)
11225 
        else:
11226 
          iprot.skip(ftype)
11227 
      else:
11228 
        iprot.skip(ftype)
11229 
      iprot.readFieldEnd()
11230 
    iprot.readStructEnd()
11231 
 
11232 
  def write(self, oprot):
11233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11235 
      return
11236 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11237 
    if self.success is not None:
1220 chandransh 11238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11240 
      for iter223 in self.success:
11241 
        iter223.write(oprot)
1220 chandransh 11242 
      oprot.writeListEnd()
11243 
      oprot.writeFieldEnd()
3431 rajveer 11244 
    if self.ex is not None:
1220 chandransh 11245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11246 
      self.ex.write(oprot)
11247 
      oprot.writeFieldEnd()
11248 
    oprot.writeFieldStop()
11249 
    oprot.writeStructEnd()
11250 
 
3431 rajveer 11251 
  def validate(self):
11252 
    return
11253 
 
11254 
 
1220 chandransh 11255 
  def __repr__(self):
11256 
    L = ['%s=%r' % (key, value)
11257 
      for key, value in self.__dict__.iteritems()]
11258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11259 
 
11260 
  def __eq__(self, other):
11261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11262 
 
11263 
  def __ne__(self, other):
11264 
    return not (self == other)
11265 
 
1208 chandransh 11266 
class markOrderAsOutOfStock_args:
11267 
  """
11268 
  Attributes:
11269 
   - orderId
11270 
  """
11271 
 
11272 
  thrift_spec = (
11273 
    None, # 0
11274 
    (1, TType.I64, 'orderId', None, None, ), # 1
11275 
  )
11276 
 
11277 
  def __init__(self, orderId=None,):
11278 
    self.orderId = orderId
11279 
 
11280 
  def read(self, iprot):
11281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11283 
      return
11284 
    iprot.readStructBegin()
11285 
    while True:
11286 
      (fname, ftype, fid) = iprot.readFieldBegin()
11287 
      if ftype == TType.STOP:
11288 
        break
11289 
      if fid == 1:
11290 
        if ftype == TType.I64:
11291 
          self.orderId = iprot.readI64();
11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      else:
11295 
        iprot.skip(ftype)
11296 
      iprot.readFieldEnd()
11297 
    iprot.readStructEnd()
11298 
 
11299 
  def write(self, oprot):
11300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11302 
      return
11303 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11304 
    if self.orderId is not None:
1208 chandransh 11305 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11306 
      oprot.writeI64(self.orderId)
11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
1208 chandransh 11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
11326 
class markOrderAsOutOfStock_result:
11327 
  """
11328 
  Attributes:
11329 
   - success
11330 
   - ex
11331 
  """
11332 
 
11333 
  thrift_spec = (
11334 
    (0, TType.BOOL, 'success', None, None, ), # 0
11335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11336 
  )
11337 
 
11338 
  def __init__(self, success=None, ex=None,):
11339 
    self.success = success
11340 
    self.ex = ex
11341 
 
11342 
  def read(self, iprot):
11343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11345 
      return
11346 
    iprot.readStructBegin()
11347 
    while True:
11348 
      (fname, ftype, fid) = iprot.readFieldBegin()
11349 
      if ftype == TType.STOP:
11350 
        break
11351 
      if fid == 0:
11352 
        if ftype == TType.BOOL:
11353 
          self.success = iprot.readBool();
11354 
        else:
11355 
          iprot.skip(ftype)
11356 
      elif fid == 1:
11357 
        if ftype == TType.STRUCT:
11358 
          self.ex = TransactionServiceException()
11359 
          self.ex.read(iprot)
11360 
        else:
11361 
          iprot.skip(ftype)
11362 
      else:
11363 
        iprot.skip(ftype)
11364 
      iprot.readFieldEnd()
11365 
    iprot.readStructEnd()
11366 
 
11367 
  def write(self, oprot):
11368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11370 
      return
11371 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11372 
    if self.success is not None:
1208 chandransh 11373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11374 
      oprot.writeBool(self.success)
11375 
      oprot.writeFieldEnd()
3431 rajveer 11376 
    if self.ex is not None:
1208 chandransh 11377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11378 
      self.ex.write(oprot)
11379 
      oprot.writeFieldEnd()
11380 
    oprot.writeFieldStop()
11381 
    oprot.writeStructEnd()
11382 
 
3431 rajveer 11383 
  def validate(self):
11384 
    return
11385 
 
11386 
 
1208 chandransh 11387 
  def __repr__(self):
11388 
    L = ['%s=%r' % (key, value)
11389 
      for key, value in self.__dict__.iteritems()]
11390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11391 
 
11392 
  def __eq__(self, other):
11393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11394 
 
11395 
  def __ne__(self, other):
11396 
    return not (self == other)
11397 
 
3064 chandransh 11398 
class verifyOrder_args:
759 chandransh 11399 
  """
11400 
  Attributes:
3064 chandransh 11401 
   - orderId
759 chandransh 11402 
  """
11403 
 
11404 
  thrift_spec = (
11405 
    None, # 0
3064 chandransh 11406 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11407 
  )
11408 
 
3064 chandransh 11409 
  def __init__(self, orderId=None,):
11410 
    self.orderId = orderId
759 chandransh 11411 
 
11412 
  def read(self, iprot):
11413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11415 
      return
11416 
    iprot.readStructBegin()
11417 
    while True:
11418 
      (fname, ftype, fid) = iprot.readFieldBegin()
11419 
      if ftype == TType.STOP:
11420 
        break
11421 
      if fid == 1:
11422 
        if ftype == TType.I64:
3064 chandransh 11423 
          self.orderId = iprot.readI64();
759 chandransh 11424 
        else:
11425 
          iprot.skip(ftype)
11426 
      else:
11427 
        iprot.skip(ftype)
11428 
      iprot.readFieldEnd()
11429 
    iprot.readStructEnd()
11430 
 
11431 
  def write(self, oprot):
11432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11434 
      return
3064 chandransh 11435 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11436 
    if self.orderId is not None:
3064 chandransh 11437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11438 
      oprot.writeI64(self.orderId)
759 chandransh 11439 
      oprot.writeFieldEnd()
11440 
    oprot.writeFieldStop()
11441 
    oprot.writeStructEnd()
11442 
 
3431 rajveer 11443 
  def validate(self):
11444 
    return
11445 
 
11446 
 
759 chandransh 11447 
  def __repr__(self):
11448 
    L = ['%s=%r' % (key, value)
11449 
      for key, value in self.__dict__.iteritems()]
11450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11451 
 
11452 
  def __eq__(self, other):
11453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11454 
 
11455 
  def __ne__(self, other):
11456 
    return not (self == other)
11457 
 
3064 chandransh 11458 
class verifyOrder_result:
759 chandransh 11459 
  """
11460 
  Attributes:
11461 
   - success
11462 
   - ex
11463 
  """
11464 
 
11465 
  thrift_spec = (
11466 
    (0, TType.BOOL, 'success', None, None, ), # 0
11467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11468 
  )
11469 
 
11470 
  def __init__(self, success=None, ex=None,):
11471 
    self.success = success
11472 
    self.ex = ex
11473 
 
11474 
  def read(self, iprot):
11475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11477 
      return
11478 
    iprot.readStructBegin()
11479 
    while True:
11480 
      (fname, ftype, fid) = iprot.readFieldBegin()
11481 
      if ftype == TType.STOP:
11482 
        break
11483 
      if fid == 0:
11484 
        if ftype == TType.BOOL:
11485 
          self.success = iprot.readBool();
11486 
        else:
11487 
          iprot.skip(ftype)
11488 
      elif fid == 1:
11489 
        if ftype == TType.STRUCT:
11490 
          self.ex = TransactionServiceException()
11491 
          self.ex.read(iprot)
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
3064 chandransh 11503 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11504 
    if self.success is not None:
759 chandransh 11505 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11506 
      oprot.writeBool(self.success)
11507 
      oprot.writeFieldEnd()
3431 rajveer 11508 
    if self.ex is not None:
759 chandransh 11509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11510 
      self.ex.write(oprot)
11511 
      oprot.writeFieldEnd()
11512 
    oprot.writeFieldStop()
11513 
    oprot.writeStructEnd()
11514 
 
3431 rajveer 11515 
  def validate(self):
11516 
    return
11517 
 
11518 
 
759 chandransh 11519 
  def __repr__(self):
11520 
    L = ['%s=%r' % (key, value)
11521 
      for key, value in self.__dict__.iteritems()]
11522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11523 
 
11524 
  def __eq__(self, other):
11525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11526 
 
11527 
  def __ne__(self, other):
11528 
    return not (self == other)
11529 
 
3064 chandransh 11530 
class acceptOrder_args:
1113 chandransh 11531 
  """
11532 
  Attributes:
3064 chandransh 11533 
   - orderId
1113 chandransh 11534 
  """
11535 
 
11536 
  thrift_spec = (
11537 
    None, # 0
3064 chandransh 11538 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11539 
  )
11540 
 
3064 chandransh 11541 
  def __init__(self, orderId=None,):
11542 
    self.orderId = orderId
1113 chandransh 11543 
 
11544 
  def read(self, iprot):
11545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11547 
      return
11548 
    iprot.readStructBegin()
11549 
    while True:
11550 
      (fname, ftype, fid) = iprot.readFieldBegin()
11551 
      if ftype == TType.STOP:
11552 
        break
11553 
      if fid == 1:
11554 
        if ftype == TType.I64:
3064 chandransh 11555 
          self.orderId = iprot.readI64();
1113 chandransh 11556 
        else:
11557 
          iprot.skip(ftype)
11558 
      else:
11559 
        iprot.skip(ftype)
11560 
      iprot.readFieldEnd()
11561 
    iprot.readStructEnd()
11562 
 
11563 
  def write(self, oprot):
11564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11566 
      return
3064 chandransh 11567 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11568 
    if self.orderId is not None:
3064 chandransh 11569 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11570 
      oprot.writeI64(self.orderId)
1113 chandransh 11571 
      oprot.writeFieldEnd()
11572 
    oprot.writeFieldStop()
11573 
    oprot.writeStructEnd()
11574 
 
3431 rajveer 11575 
  def validate(self):
11576 
    return
11577 
 
11578 
 
1113 chandransh 11579 
  def __repr__(self):
11580 
    L = ['%s=%r' % (key, value)
11581 
      for key, value in self.__dict__.iteritems()]
11582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11583 
 
11584 
  def __eq__(self, other):
11585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11586 
 
11587 
  def __ne__(self, other):
11588 
    return not (self == other)
11589 
 
3064 chandransh 11590 
class acceptOrder_result:
1113 chandransh 11591 
  """
11592 
  Attributes:
11593 
   - success
11594 
   - ex
11595 
  """
11596 
 
11597 
  thrift_spec = (
3064 chandransh 11598 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11600 
  )
11601 
 
11602 
  def __init__(self, success=None, ex=None,):
11603 
    self.success = success
11604 
    self.ex = ex
11605 
 
11606 
  def read(self, iprot):
11607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11609 
      return
11610 
    iprot.readStructBegin()
11611 
    while True:
11612 
      (fname, ftype, fid) = iprot.readFieldBegin()
11613 
      if ftype == TType.STOP:
11614 
        break
11615 
      if fid == 0:
3064 chandransh 11616 
        if ftype == TType.BOOL:
11617 
          self.success = iprot.readBool();
1113 chandransh 11618 
        else:
11619 
          iprot.skip(ftype)
11620 
      elif fid == 1:
11621 
        if ftype == TType.STRUCT:
11622 
          self.ex = TransactionServiceException()
11623 
          self.ex.read(iprot)
11624 
        else:
11625 
          iprot.skip(ftype)
11626 
      else:
11627 
        iprot.skip(ftype)
11628 
      iprot.readFieldEnd()
11629 
    iprot.readStructEnd()
11630 
 
11631 
  def write(self, oprot):
11632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11634 
      return
3064 chandransh 11635 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11636 
    if self.success is not None:
3064 chandransh 11637 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11638 
      oprot.writeBool(self.success)
1113 chandransh 11639 
      oprot.writeFieldEnd()
3431 rajveer 11640 
    if self.ex is not None:
1113 chandransh 11641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11642 
      self.ex.write(oprot)
11643 
      oprot.writeFieldEnd()
11644 
    oprot.writeFieldStop()
11645 
    oprot.writeStructEnd()
11646 
 
3431 rajveer 11647 
  def validate(self):
11648 
    return
11649 
 
11650 
 
1113 chandransh 11651 
  def __repr__(self):
11652 
    L = ['%s=%r' % (key, value)
11653 
      for key, value in self.__dict__.iteritems()]
11654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11655 
 
11656 
  def __eq__(self, other):
11657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11658 
 
11659 
  def __ne__(self, other):
11660 
    return not (self == other)
11661 
 
3064 chandransh 11662 
class addBillingDetails_args:
1135 chandransh 11663 
  """
11664 
  Attributes:
3064 chandransh 11665 
   - orderId
11666 
   - invoice_number
4658 mandeep.dh 11667 
   - serialNumber
4283 anupam.sin 11668 
   - itemNumber
3064 chandransh 11669 
   - billed_by
4264 rajveer 11670 
   - jacketNumber
4283 anupam.sin 11671 
   - billingType
5110 mandeep.dh 11672 
   - fulfilmentWarehouseId
4763 rajveer 11673 
   - authorize
1135 chandransh 11674 
  """
11675 
 
11676 
  thrift_spec = (
11677 
    None, # 0
3064 chandransh 11678 
    (1, TType.I64, 'orderId', None, None, ), # 1
11679 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11680 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11681 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11682 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11683 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11684 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11685 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11686 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11687 
  )
11688 
 
5110 mandeep.dh 11689 
  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 11690 
    self.orderId = orderId
11691 
    self.invoice_number = invoice_number
4658 mandeep.dh 11692 
    self.serialNumber = serialNumber
4283 anupam.sin 11693 
    self.itemNumber = itemNumber
3064 chandransh 11694 
    self.billed_by = billed_by
4264 rajveer 11695 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11696 
    self.billingType = billingType
5110 mandeep.dh 11697 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11698 
    self.authorize = authorize
1135 chandransh 11699 
 
11700 
  def read(self, iprot):
11701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11703 
      return
11704 
    iprot.readStructBegin()
11705 
    while True:
11706 
      (fname, ftype, fid) = iprot.readFieldBegin()
11707 
      if ftype == TType.STOP:
11708 
        break
11709 
      if fid == 1:
11710 
        if ftype == TType.I64:
3064 chandransh 11711 
          self.orderId = iprot.readI64();
1135 chandransh 11712 
        else:
11713 
          iprot.skip(ftype)
11714 
      elif fid == 2:
3064 chandransh 11715 
        if ftype == TType.STRING:
11716 
          self.invoice_number = iprot.readString();
1135 chandransh 11717 
        else:
11718 
          iprot.skip(ftype)
3064 chandransh 11719 
      elif fid == 3:
4658 mandeep.dh 11720 
        if ftype == TType.STRING:
11721 
          self.serialNumber = iprot.readString();
3064 chandransh 11722 
        else:
11723 
          iprot.skip(ftype)
11724 
      elif fid == 4:
11725 
        if ftype == TType.STRING:
11726 
          self.itemNumber = iprot.readString();
11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      elif fid == 5:
11730 
        if ftype == TType.STRING:
4283 anupam.sin 11731 
          self.billed_by = iprot.readString();
3064 chandransh 11732 
        else:
11733 
          iprot.skip(ftype)
11734 
      elif fid == 6:
11735 
        if ftype == TType.I64:
4283 anupam.sin 11736 
          self.jacketNumber = iprot.readI64();
11737 
        else:
11738 
          iprot.skip(ftype)
11739 
      elif fid == 7:
11740 
        if ftype == TType.I64:
3064 chandransh 11741 
          self.billingType = iprot.readI64();
11742 
        else:
11743 
          iprot.skip(ftype)
4283 anupam.sin 11744 
      elif fid == 8:
11745 
        if ftype == TType.I64:
5110 mandeep.dh 11746 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11747 
        else:
11748 
          iprot.skip(ftype)
4763 rajveer 11749 
      elif fid == 9:
11750 
        if ftype == TType.BOOL:
11751 
          self.authorize = iprot.readBool();
11752 
        else:
11753 
          iprot.skip(ftype)
1246 chandransh 11754 
      else:
11755 
        iprot.skip(ftype)
11756 
      iprot.readFieldEnd()
11757 
    iprot.readStructEnd()
11758 
 
11759 
  def write(self, oprot):
11760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11762 
      return
4283 anupam.sin 11763 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11764 
    if self.orderId is not None:
3064 chandransh 11765 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11766 
      oprot.writeI64(self.orderId)
1246 chandransh 11767 
      oprot.writeFieldEnd()
4283 anupam.sin 11768 
    if self.invoice_number is not None:
11769 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11770 
      oprot.writeString(self.invoice_number)
1246 chandransh 11771 
      oprot.writeFieldEnd()
4658 mandeep.dh 11772 
    if self.serialNumber is not None:
11773 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11774 
      oprot.writeString(self.serialNumber)
3064 chandransh 11775 
      oprot.writeFieldEnd()
3431 rajveer 11776 
    if self.itemNumber is not None:
3064 chandransh 11777 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11778 
      oprot.writeString(self.itemNumber)
11779 
      oprot.writeFieldEnd()
4283 anupam.sin 11780 
    if self.billed_by is not None:
11781 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11782 
      oprot.writeString(self.billed_by)
3064 chandransh 11783 
      oprot.writeFieldEnd()
4283 anupam.sin 11784 
    if self.jacketNumber is not None:
11785 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11786 
      oprot.writeI64(self.jacketNumber)
11787 
      oprot.writeFieldEnd()
3431 rajveer 11788 
    if self.billingType is not None:
4283 anupam.sin 11789 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11790 
      oprot.writeI64(self.billingType)
11791 
      oprot.writeFieldEnd()
5110 mandeep.dh 11792 
    if self.fulfilmentWarehouseId is not None:
11793 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11794 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11795 
      oprot.writeFieldEnd()
4763 rajveer 11796 
    if self.authorize is not None:
11797 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11798 
      oprot.writeBool(self.authorize)
11799 
      oprot.writeFieldEnd()
1246 chandransh 11800 
    oprot.writeFieldStop()
11801 
    oprot.writeStructEnd()
11802 
 
3431 rajveer 11803 
  def validate(self):
11804 
    return
11805 
 
11806 
 
1246 chandransh 11807 
  def __repr__(self):
11808 
    L = ['%s=%r' % (key, value)
11809 
      for key, value in self.__dict__.iteritems()]
11810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11811 
 
11812 
  def __eq__(self, other):
11813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11814 
 
11815 
  def __ne__(self, other):
11816 
    return not (self == other)
11817 
 
4283 anupam.sin 11818 
class addBillingDetails_result:
1246 chandransh 11819 
  """
11820 
  Attributes:
3064 chandransh 11821 
   - success
1246 chandransh 11822 
   - ex
11823 
  """
11824 
 
11825 
  thrift_spec = (
3064 chandransh 11826 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11828 
  )
11829 
 
3064 chandransh 11830 
  def __init__(self, success=None, ex=None,):
11831 
    self.success = success
1246 chandransh 11832 
    self.ex = ex
11833 
 
11834 
  def read(self, iprot):
11835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11837 
      return
11838 
    iprot.readStructBegin()
11839 
    while True:
11840 
      (fname, ftype, fid) = iprot.readFieldBegin()
11841 
      if ftype == TType.STOP:
11842 
        break
3064 chandransh 11843 
      if fid == 0:
11844 
        if ftype == TType.BOOL:
11845 
          self.success = iprot.readBool();
11846 
        else:
11847 
          iprot.skip(ftype)
11848 
      elif fid == 1:
1246 chandransh 11849 
        if ftype == TType.STRUCT:
11850 
          self.ex = TransactionServiceException()
11851 
          self.ex.read(iprot)
11852 
        else:
11853 
          iprot.skip(ftype)
11854 
      else:
11855 
        iprot.skip(ftype)
11856 
      iprot.readFieldEnd()
11857 
    iprot.readStructEnd()
11858 
 
11859 
  def write(self, oprot):
11860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11862 
      return
4283 anupam.sin 11863 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11864 
    if self.success is not None:
3064 chandransh 11865 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11866 
      oprot.writeBool(self.success)
11867 
      oprot.writeFieldEnd()
3431 rajveer 11868 
    if self.ex is not None:
1246 chandransh 11869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11870 
      self.ex.write(oprot)
11871 
      oprot.writeFieldEnd()
11872 
    oprot.writeFieldStop()
11873 
    oprot.writeStructEnd()
11874 
 
3431 rajveer 11875 
  def validate(self):
11876 
    return
11877 
 
11878 
 
1246 chandransh 11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
4579 rajveer 11890 
class addInvoiceNumber_args:
11891 
  """
11892 
  Attributes:
11893 
   - orderId
11894 
   - invoiceNumber
4763 rajveer 11895 
   - color
4579 rajveer 11896 
  """
11897 
 
11898 
  thrift_spec = (
11899 
    None, # 0
11900 
    (1, TType.I64, 'orderId', None, None, ), # 1
11901 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11902 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11903 
  )
11904 
 
4763 rajveer 11905 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11906 
    self.orderId = orderId
11907 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11908 
    self.color = color
4579 rajveer 11909 
 
11910 
  def read(self, iprot):
11911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11913 
      return
11914 
    iprot.readStructBegin()
11915 
    while True:
11916 
      (fname, ftype, fid) = iprot.readFieldBegin()
11917 
      if ftype == TType.STOP:
11918 
        break
11919 
      if fid == 1:
11920 
        if ftype == TType.I64:
11921 
          self.orderId = iprot.readI64();
11922 
        else:
11923 
          iprot.skip(ftype)
11924 
      elif fid == 2:
11925 
        if ftype == TType.STRING:
11926 
          self.invoiceNumber = iprot.readString();
11927 
        else:
11928 
          iprot.skip(ftype)
4763 rajveer 11929 
      elif fid == 3:
11930 
        if ftype == TType.STRING:
11931 
          self.color = iprot.readString();
11932 
        else:
11933 
          iprot.skip(ftype)
4579 rajveer 11934 
      else:
11935 
        iprot.skip(ftype)
11936 
      iprot.readFieldEnd()
11937 
    iprot.readStructEnd()
11938 
 
11939 
  def write(self, oprot):
11940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11942 
      return
11943 
    oprot.writeStructBegin('addInvoiceNumber_args')
11944 
    if self.orderId is not None:
11945 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11946 
      oprot.writeI64(self.orderId)
11947 
      oprot.writeFieldEnd()
11948 
    if self.invoiceNumber is not None:
11949 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11950 
      oprot.writeString(self.invoiceNumber)
11951 
      oprot.writeFieldEnd()
4763 rajveer 11952 
    if self.color is not None:
11953 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11954 
      oprot.writeString(self.color)
11955 
      oprot.writeFieldEnd()
4579 rajveer 11956 
    oprot.writeFieldStop()
11957 
    oprot.writeStructEnd()
11958 
 
11959 
  def validate(self):
11960 
    return
11961 
 
11962 
 
11963 
  def __repr__(self):
11964 
    L = ['%s=%r' % (key, value)
11965 
      for key, value in self.__dict__.iteritems()]
11966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11967 
 
11968 
  def __eq__(self, other):
11969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11970 
 
11971 
  def __ne__(self, other):
11972 
    return not (self == other)
11973 
 
11974 
class addInvoiceNumber_result:
11975 
  """
11976 
  Attributes:
11977 
   - ex
11978 
  """
11979 
 
11980 
  thrift_spec = (
11981 
    None, # 0
11982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11983 
  )
11984 
 
11985 
  def __init__(self, ex=None,):
11986 
    self.ex = ex
11987 
 
11988 
  def read(self, iprot):
11989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11991 
      return
11992 
    iprot.readStructBegin()
11993 
    while True:
11994 
      (fname, ftype, fid) = iprot.readFieldBegin()
11995 
      if ftype == TType.STOP:
11996 
        break
11997 
      if fid == 1:
11998 
        if ftype == TType.STRUCT:
11999 
          self.ex = TransactionServiceException()
12000 
          self.ex.read(iprot)
12001 
        else:
12002 
          iprot.skip(ftype)
12003 
      else:
12004 
        iprot.skip(ftype)
12005 
      iprot.readFieldEnd()
12006 
    iprot.readStructEnd()
12007 
 
12008 
  def write(self, oprot):
12009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12011 
      return
12012 
    oprot.writeStructBegin('addInvoiceNumber_result')
12013 
    if self.ex is not None:
12014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12015 
      self.ex.write(oprot)
12016 
      oprot.writeFieldEnd()
12017 
    oprot.writeFieldStop()
12018 
    oprot.writeStructEnd()
12019 
 
12020 
  def validate(self):
12021 
    return
12022 
 
12023 
 
12024 
  def __repr__(self):
12025 
    L = ['%s=%r' % (key, value)
12026 
      for key, value in self.__dict__.iteritems()]
12027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12028 
 
12029 
  def __eq__(self, other):
12030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12031 
 
12032 
  def __ne__(self, other):
12033 
    return not (self == other)
12034 
 
4910 phani.kuma 12035 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12036 
  """
12037 
  Attributes:
3064 chandransh 12038 
   - warehouseId
1408 ankur.sing 12039 
   - providerId
3064 chandransh 12040 
   - cod
4910 phani.kuma 12041 
   - orderIds
1408 ankur.sing 12042 
  """
12043 
 
12044 
  thrift_spec = (
12045 
    None, # 0
3064 chandransh 12046 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12047 
    (2, TType.I64, 'providerId', None, None, ), # 2
12048 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12049 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12050 
  )
12051 
 
4910 phani.kuma 12052 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12053 
    self.warehouseId = warehouseId
1408 ankur.sing 12054 
    self.providerId = providerId
3064 chandransh 12055 
    self.cod = cod
4910 phani.kuma 12056 
    self.orderIds = orderIds
1408 ankur.sing 12057 
 
12058 
  def read(self, iprot):
12059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12061 
      return
12062 
    iprot.readStructBegin()
12063 
    while True:
12064 
      (fname, ftype, fid) = iprot.readFieldBegin()
12065 
      if ftype == TType.STOP:
12066 
        break
12067 
      if fid == 1:
12068 
        if ftype == TType.I64:
3064 chandransh 12069 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12070 
        else:
12071 
          iprot.skip(ftype)
12072 
      elif fid == 2:
12073 
        if ftype == TType.I64:
3064 chandransh 12074 
          self.providerId = iprot.readI64();
1408 ankur.sing 12075 
        else:
12076 
          iprot.skip(ftype)
3064 chandransh 12077 
      elif fid == 3:
12078 
        if ftype == TType.BOOL:
12079 
          self.cod = iprot.readBool();
12080 
        else:
12081 
          iprot.skip(ftype)
4910 phani.kuma 12082 
      elif fid == 4:
12083 
        if ftype == TType.LIST:
12084 
          self.orderIds = []
5386 phani.kuma 12085 
          (_etype227, _size224) = iprot.readListBegin()
12086 
          for _i228 in xrange(_size224):
12087 
            _elem229 = iprot.readI64();
12088 
            self.orderIds.append(_elem229)
4910 phani.kuma 12089 
          iprot.readListEnd()
12090 
        else:
12091 
          iprot.skip(ftype)
1408 ankur.sing 12092 
      else:
12093 
        iprot.skip(ftype)
12094 
      iprot.readFieldEnd()
12095 
    iprot.readStructEnd()
12096 
 
12097 
  def write(self, oprot):
12098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12100 
      return
4910 phani.kuma 12101 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12102 
    if self.warehouseId is not None:
3064 chandransh 12103 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12104 
      oprot.writeI64(self.warehouseId)
12105 
      oprot.writeFieldEnd()
3431 rajveer 12106 
    if self.providerId is not None:
3064 chandransh 12107 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12108 
      oprot.writeI64(self.providerId)
12109 
      oprot.writeFieldEnd()
3431 rajveer 12110 
    if self.cod is not None:
3064 chandransh 12111 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12112 
      oprot.writeBool(self.cod)
1408 ankur.sing 12113 
      oprot.writeFieldEnd()
4910 phani.kuma 12114 
    if self.orderIds is not None:
12115 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12116 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5386 phani.kuma 12117 
      for iter230 in self.orderIds:
12118 
        oprot.writeI64(iter230)
4910 phani.kuma 12119 
      oprot.writeListEnd()
12120 
      oprot.writeFieldEnd()
1408 ankur.sing 12121 
    oprot.writeFieldStop()
12122 
    oprot.writeStructEnd()
12123 
 
3431 rajveer 12124 
  def validate(self):
12125 
    return
12126 
 
12127 
 
1408 ankur.sing 12128 
  def __repr__(self):
12129 
    L = ['%s=%r' % (key, value)
12130 
      for key, value in self.__dict__.iteritems()]
12131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12132 
 
12133 
  def __eq__(self, other):
12134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12135 
 
12136 
  def __ne__(self, other):
12137 
    return not (self == other)
12138 
 
4910 phani.kuma 12139 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12140 
  """
12141 
  Attributes:
12142 
   - success
3064 chandransh 12143 
   - ex
1408 ankur.sing 12144 
  """
12145 
 
12146 
  thrift_spec = (
3064 chandransh 12147 
    (0, TType.BOOL, 'success', None, None, ), # 0
12148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12149 
  )
12150 
 
3064 chandransh 12151 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12152 
    self.success = success
3064 chandransh 12153 
    self.ex = ex
1408 ankur.sing 12154 
 
12155 
  def read(self, iprot):
12156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12158 
      return
12159 
    iprot.readStructBegin()
12160 
    while True:
12161 
      (fname, ftype, fid) = iprot.readFieldBegin()
12162 
      if ftype == TType.STOP:
12163 
        break
12164 
      if fid == 0:
3064 chandransh 12165 
        if ftype == TType.BOOL:
12166 
          self.success = iprot.readBool();
1408 ankur.sing 12167 
        else:
12168 
          iprot.skip(ftype)
3064 chandransh 12169 
      elif fid == 1:
12170 
        if ftype == TType.STRUCT:
12171 
          self.ex = TransactionServiceException()
12172 
          self.ex.read(iprot)
12173 
        else:
12174 
          iprot.skip(ftype)
1408 ankur.sing 12175 
      else:
12176 
        iprot.skip(ftype)
12177 
      iprot.readFieldEnd()
12178 
    iprot.readStructEnd()
12179 
 
12180 
  def write(self, oprot):
12181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12183 
      return
4910 phani.kuma 12184 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12185 
    if self.success is not None:
3064 chandransh 12186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12187 
      oprot.writeBool(self.success)
1408 ankur.sing 12188 
      oprot.writeFieldEnd()
3431 rajveer 12189 
    if self.ex is not None:
3064 chandransh 12190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12191 
      self.ex.write(oprot)
12192 
      oprot.writeFieldEnd()
1408 ankur.sing 12193 
    oprot.writeFieldStop()
12194 
    oprot.writeStructEnd()
12195 
 
3431 rajveer 12196 
  def validate(self):
12197 
    return
12198 
 
12199 
 
1408 ankur.sing 12200 
  def __repr__(self):
12201 
    L = ['%s=%r' % (key, value)
12202 
      for key, value in self.__dict__.iteritems()]
12203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12204 
 
12205 
  def __eq__(self, other):
12206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12207 
 
12208 
  def __ne__(self, other):
12209 
    return not (self == other)
12210 
 
4910 phani.kuma 12211 
class markOrdersAsPickedUp_args:
4410 rajveer 12212 
  """
12213 
  Attributes:
12214 
   - providerId
4910 phani.kuma 12215 
   - pickupDetails
4410 rajveer 12216 
  """
12217 
 
12218 
  thrift_spec = (
12219 
    None, # 0
4910 phani.kuma 12220 
    (1, TType.I64, 'providerId', None, None, ), # 1
12221 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12222 
  )
12223 
 
4910 phani.kuma 12224 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12225 
    self.providerId = providerId
4910 phani.kuma 12226 
    self.pickupDetails = pickupDetails
4410 rajveer 12227 
 
12228 
  def read(self, iprot):
12229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12231 
      return
12232 
    iprot.readStructBegin()
12233 
    while True:
12234 
      (fname, ftype, fid) = iprot.readFieldBegin()
12235 
      if ftype == TType.STOP:
12236 
        break
12237 
      if fid == 1:
12238 
        if ftype == TType.I64:
4910 phani.kuma 12239 
          self.providerId = iprot.readI64();
4410 rajveer 12240 
        else:
12241 
          iprot.skip(ftype)
12242 
      elif fid == 2:
4910 phani.kuma 12243 
        if ftype == TType.MAP:
12244 
          self.pickupDetails = {}
5386 phani.kuma 12245 
          (_ktype232, _vtype233, _size231 ) = iprot.readMapBegin()
12246 
          for _i235 in xrange(_size231):
12247 
            _key236 = iprot.readString();
12248 
            _val237 = iprot.readString();
12249 
            self.pickupDetails[_key236] = _val237
4910 phani.kuma 12250 
          iprot.readMapEnd()
4410 rajveer 12251 
        else:
12252 
          iprot.skip(ftype)
12253 
      else:
12254 
        iprot.skip(ftype)
12255 
      iprot.readFieldEnd()
12256 
    iprot.readStructEnd()
12257 
 
12258 
  def write(self, oprot):
12259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12261 
      return
4910 phani.kuma 12262 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12263 
    if self.providerId is not None:
4910 phani.kuma 12264 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12265 
      oprot.writeI64(self.providerId)
12266 
      oprot.writeFieldEnd()
4910 phani.kuma 12267 
    if self.pickupDetails is not None:
12268 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12269 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5386 phani.kuma 12270 
      for kiter238,viter239 in self.pickupDetails.items():
12271 
        oprot.writeString(kiter238)
12272 
        oprot.writeString(viter239)
4910 phani.kuma 12273 
      oprot.writeMapEnd()
4410 rajveer 12274 
      oprot.writeFieldEnd()
12275 
    oprot.writeFieldStop()
12276 
    oprot.writeStructEnd()
12277 
 
12278 
  def validate(self):
12279 
    return
12280 
 
12281 
 
12282 
  def __repr__(self):
12283 
    L = ['%s=%r' % (key, value)
12284 
      for key, value in self.__dict__.iteritems()]
12285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12286 
 
12287 
  def __eq__(self, other):
12288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12289 
 
12290 
  def __ne__(self, other):
12291 
    return not (self == other)
12292 
 
4910 phani.kuma 12293 
class markOrdersAsPickedUp_result:
4410 rajveer 12294 
  """
12295 
  Attributes:
12296 
   - ex
12297 
  """
12298 
 
12299 
  thrift_spec = (
4910 phani.kuma 12300 
    None, # 0
4410 rajveer 12301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12302 
  )
12303 
 
4910 phani.kuma 12304 
  def __init__(self, ex=None,):
4410 rajveer 12305 
    self.ex = ex
12306 
 
12307 
  def read(self, iprot):
12308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12310 
      return
12311 
    iprot.readStructBegin()
12312 
    while True:
12313 
      (fname, ftype, fid) = iprot.readFieldBegin()
12314 
      if ftype == TType.STOP:
12315 
        break
4910 phani.kuma 12316 
      if fid == 1:
4410 rajveer 12317 
        if ftype == TType.STRUCT:
12318 
          self.ex = TransactionServiceException()
12319 
          self.ex.read(iprot)
12320 
        else:
12321 
          iprot.skip(ftype)
12322 
      else:
12323 
        iprot.skip(ftype)
12324 
      iprot.readFieldEnd()
12325 
    iprot.readStructEnd()
12326 
 
12327 
  def write(self, oprot):
12328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12330 
      return
4910 phani.kuma 12331 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12332 
    if self.ex is not None:
12333 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12334 
      self.ex.write(oprot)
12335 
      oprot.writeFieldEnd()
12336 
    oprot.writeFieldStop()
12337 
    oprot.writeStructEnd()
12338 
 
12339 
  def validate(self):
12340 
    return
12341 
 
12342 
 
12343 
  def __repr__(self):
12344 
    L = ['%s=%r' % (key, value)
12345 
      for key, value in self.__dict__.iteritems()]
12346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12347 
 
12348 
  def __eq__(self, other):
12349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12350 
 
12351 
  def __ne__(self, other):
12352 
    return not (self == other)
12353 
 
4910 phani.kuma 12354 
class getOrdersNotPickedUp_args:
304 ashish 12355 
  """
12356 
  Attributes:
3064 chandransh 12357 
   - providerId
304 ashish 12358 
  """
94 ashish 12359 
 
304 ashish 12360 
  thrift_spec = (
12361 
    None, # 0
3064 chandransh 12362 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12363 
  )
12364 
 
4910 phani.kuma 12365 
  def __init__(self, providerId=None,):
3064 chandransh 12366 
    self.providerId = providerId
304 ashish 12367 
 
12368 
  def read(self, iprot):
12369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12371 
      return
12372 
    iprot.readStructBegin()
12373 
    while True:
12374 
      (fname, ftype, fid) = iprot.readFieldBegin()
12375 
      if ftype == TType.STOP:
12376 
        break
12377 
      if fid == 1:
12378 
        if ftype == TType.I64:
3064 chandransh 12379 
          self.providerId = iprot.readI64();
304 ashish 12380 
        else:
12381 
          iprot.skip(ftype)
12382 
      else:
12383 
        iprot.skip(ftype)
12384 
      iprot.readFieldEnd()
12385 
    iprot.readStructEnd()
12386 
 
12387 
  def write(self, oprot):
12388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12390 
      return
4910 phani.kuma 12391 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12392 
    if self.providerId is not None:
3064 chandransh 12393 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12394 
      oprot.writeI64(self.providerId)
304 ashish 12395 
      oprot.writeFieldEnd()
12396 
    oprot.writeFieldStop()
12397 
    oprot.writeStructEnd()
12398 
 
3431 rajveer 12399 
  def validate(self):
12400 
    return
12401 
 
12402 
 
304 ashish 12403 
  def __repr__(self):
12404 
    L = ['%s=%r' % (key, value)
12405 
      for key, value in self.__dict__.iteritems()]
12406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12407 
 
12408 
  def __eq__(self, other):
12409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12410 
 
12411 
  def __ne__(self, other):
12412 
    return not (self == other)
12413 
 
4910 phani.kuma 12414 
class getOrdersNotPickedUp_result:
304 ashish 12415 
  """
12416 
  Attributes:
12417 
   - success
12418 
  """
12419 
 
12420 
  thrift_spec = (
3064 chandransh 12421 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12422 
  )
12423 
 
4910 phani.kuma 12424 
  def __init__(self, success=None,):
304 ashish 12425 
    self.success = success
12426 
 
12427 
  def read(self, iprot):
12428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12430 
      return
12431 
    iprot.readStructBegin()
12432 
    while True:
12433 
      (fname, ftype, fid) = iprot.readFieldBegin()
12434 
      if ftype == TType.STOP:
12435 
        break
12436 
      if fid == 0:
12437 
        if ftype == TType.LIST:
12438 
          self.success = []
5386 phani.kuma 12439 
          (_etype243, _size240) = iprot.readListBegin()
12440 
          for _i244 in xrange(_size240):
12441 
            _elem245 = Order()
12442 
            _elem245.read(iprot)
12443 
            self.success.append(_elem245)
304 ashish 12444 
          iprot.readListEnd()
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
4910 phani.kuma 12456 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12457 
    if self.success is not None:
304 ashish 12458 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12459 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 12460 
      for iter246 in self.success:
12461 
        iter246.write(oprot)
304 ashish 12462 
      oprot.writeListEnd()
12463 
      oprot.writeFieldEnd()
12464 
    oprot.writeFieldStop()
12465 
    oprot.writeStructEnd()
12466 
 
3431 rajveer 12467 
  def validate(self):
12468 
    return
12469 
 
12470 
 
304 ashish 12471 
  def __repr__(self):
12472 
    L = ['%s=%r' % (key, value)
12473 
      for key, value in self.__dict__.iteritems()]
12474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12475 
 
12476 
  def __eq__(self, other):
12477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12478 
 
12479 
  def __ne__(self, other):
12480 
    return not (self == other)
12481 
 
3064 chandransh 12482 
class markOrdersAsDelivered_args:
304 ashish 12483 
  """
12484 
  Attributes:
3064 chandransh 12485 
   - providerId
12486 
   - deliveredOrders
304 ashish 12487 
  """
12488 
 
12489 
  thrift_spec = (
12490 
    None, # 0
3064 chandransh 12491 
    (1, TType.I64, 'providerId', None, None, ), # 1
12492 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12493 
  )
12494 
 
3064 chandransh 12495 
  def __init__(self, providerId=None, deliveredOrders=None,):
12496 
    self.providerId = providerId
12497 
    self.deliveredOrders = deliveredOrders
304 ashish 12498 
 
12499 
  def read(self, iprot):
12500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12502 
      return
12503 
    iprot.readStructBegin()
12504 
    while True:
12505 
      (fname, ftype, fid) = iprot.readFieldBegin()
12506 
      if ftype == TType.STOP:
12507 
        break
12508 
      if fid == 1:
12509 
        if ftype == TType.I64:
3064 chandransh 12510 
          self.providerId = iprot.readI64();
304 ashish 12511 
        else:
12512 
          iprot.skip(ftype)
12513 
      elif fid == 2:
3064 chandransh 12514 
        if ftype == TType.MAP:
12515 
          self.deliveredOrders = {}
5386 phani.kuma 12516 
          (_ktype248, _vtype249, _size247 ) = iprot.readMapBegin()
12517 
          for _i251 in xrange(_size247):
12518 
            _key252 = iprot.readString();
12519 
            _val253 = iprot.readString();
12520 
            self.deliveredOrders[_key252] = _val253
3064 chandransh 12521 
          iprot.readMapEnd()
304 ashish 12522 
        else:
12523 
          iprot.skip(ftype)
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
3064 chandransh 12533 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12534 
    if self.providerId is not None:
3064 chandransh 12535 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12536 
      oprot.writeI64(self.providerId)
304 ashish 12537 
      oprot.writeFieldEnd()
3431 rajveer 12538 
    if self.deliveredOrders is not None:
3064 chandransh 12539 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12540 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5386 phani.kuma 12541 
      for kiter254,viter255 in self.deliveredOrders.items():
12542 
        oprot.writeString(kiter254)
12543 
        oprot.writeString(viter255)
3064 chandransh 12544 
      oprot.writeMapEnd()
304 ashish 12545 
      oprot.writeFieldEnd()
12546 
    oprot.writeFieldStop()
12547 
    oprot.writeStructEnd()
12548 
 
3431 rajveer 12549 
  def validate(self):
12550 
    return
12551 
 
12552 
 
304 ashish 12553 
  def __repr__(self):
12554 
    L = ['%s=%r' % (key, value)
12555 
      for key, value in self.__dict__.iteritems()]
12556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12557 
 
12558 
  def __eq__(self, other):
12559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12560 
 
12561 
  def __ne__(self, other):
12562 
    return not (self == other)
12563 
 
3064 chandransh 12564 
class markOrdersAsDelivered_result:
12565 
  """
12566 
  Attributes:
12567 
   - ex
12568 
  """
304 ashish 12569 
 
12570 
  thrift_spec = (
3064 chandransh 12571 
    None, # 0
12572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12573 
  )
12574 
 
3064 chandransh 12575 
  def __init__(self, ex=None,):
12576 
    self.ex = ex
304 ashish 12577 
 
1596 ankur.sing 12578 
  def read(self, iprot):
12579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12581 
      return
12582 
    iprot.readStructBegin()
12583 
    while True:
12584 
      (fname, ftype, fid) = iprot.readFieldBegin()
12585 
      if ftype == TType.STOP:
12586 
        break
3064 chandransh 12587 
      if fid == 1:
12588 
        if ftype == TType.STRUCT:
12589 
          self.ex = TransactionServiceException()
12590 
          self.ex.read(iprot)
12591 
        else:
12592 
          iprot.skip(ftype)
1596 ankur.sing 12593 
      else:
12594 
        iprot.skip(ftype)
12595 
      iprot.readFieldEnd()
12596 
    iprot.readStructEnd()
12597 
 
12598 
  def write(self, oprot):
12599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12601 
      return
3064 chandransh 12602 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12603 
    if self.ex is not None:
3064 chandransh 12604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12605 
      self.ex.write(oprot)
12606 
      oprot.writeFieldEnd()
1596 ankur.sing 12607 
    oprot.writeFieldStop()
12608 
    oprot.writeStructEnd()
12609 
 
3431 rajveer 12610 
  def validate(self):
12611 
    return
12612 
 
12613 
 
1596 ankur.sing 12614 
  def __repr__(self):
12615 
    L = ['%s=%r' % (key, value)
12616 
      for key, value in self.__dict__.iteritems()]
12617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12618 
 
12619 
  def __eq__(self, other):
12620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12621 
 
12622 
  def __ne__(self, other):
12623 
    return not (self == other)
12624 
 
4910 phani.kuma 12625 
class markAsRTOrders_args:
1596 ankur.sing 12626 
  """
12627 
  Attributes:
3064 chandransh 12628 
   - providerId
12629 
   - returnedOrders
1596 ankur.sing 12630 
  """
12631 
 
12632 
  thrift_spec = (
3064 chandransh 12633 
    None, # 0
12634 
    (1, TType.I64, 'providerId', None, None, ), # 1
12635 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12636 
  )
12637 
 
3064 chandransh 12638 
  def __init__(self, providerId=None, returnedOrders=None,):
12639 
    self.providerId = providerId
12640 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12641 
 
12642 
  def read(self, iprot):
12643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12645 
      return
12646 
    iprot.readStructBegin()
12647 
    while True:
12648 
      (fname, ftype, fid) = iprot.readFieldBegin()
12649 
      if ftype == TType.STOP:
12650 
        break
3064 chandransh 12651 
      if fid == 1:
1596 ankur.sing 12652 
        if ftype == TType.I64:
3064 chandransh 12653 
          self.providerId = iprot.readI64();
1596 ankur.sing 12654 
        else:
12655 
          iprot.skip(ftype)
3064 chandransh 12656 
      elif fid == 2:
12657 
        if ftype == TType.MAP:
12658 
          self.returnedOrders = {}
5386 phani.kuma 12659 
          (_ktype257, _vtype258, _size256 ) = iprot.readMapBegin()
12660 
          for _i260 in xrange(_size256):
12661 
            _key261 = iprot.readString();
12662 
            _val262 = iprot.readString();
12663 
            self.returnedOrders[_key261] = _val262
3064 chandransh 12664 
          iprot.readMapEnd()
12665 
        else:
12666 
          iprot.skip(ftype)
1596 ankur.sing 12667 
      else:
12668 
        iprot.skip(ftype)
12669 
      iprot.readFieldEnd()
12670 
    iprot.readStructEnd()
12671 
 
12672 
  def write(self, oprot):
12673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12675 
      return
4910 phani.kuma 12676 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12677 
    if self.providerId is not None:
3064 chandransh 12678 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12679 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12680 
      oprot.writeFieldEnd()
3431 rajveer 12681 
    if self.returnedOrders is not None:
3064 chandransh 12682 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12683 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5386 phani.kuma 12684 
      for kiter263,viter264 in self.returnedOrders.items():
12685 
        oprot.writeString(kiter263)
12686 
        oprot.writeString(viter264)
3064 chandransh 12687 
      oprot.writeMapEnd()
12688 
      oprot.writeFieldEnd()
1596 ankur.sing 12689 
    oprot.writeFieldStop()
12690 
    oprot.writeStructEnd()
12691 
 
3431 rajveer 12692 
  def validate(self):
12693 
    return
12694 
 
12695 
 
1596 ankur.sing 12696 
  def __repr__(self):
12697 
    L = ['%s=%r' % (key, value)
12698 
      for key, value in self.__dict__.iteritems()]
12699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12700 
 
12701 
  def __eq__(self, other):
12702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12703 
 
12704 
  def __ne__(self, other):
12705 
    return not (self == other)
12706 
 
4910 phani.kuma 12707 
class markAsRTOrders_result:
3064 chandransh 12708 
  """
12709 
  Attributes:
12710 
   - ex
12711 
  """
1596 ankur.sing 12712 
 
1627 ankur.sing 12713 
  thrift_spec = (
3064 chandransh 12714 
    None, # 0
12715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12716 
  )
12717 
 
3064 chandransh 12718 
  def __init__(self, ex=None,):
12719 
    self.ex = ex
12720 
 
1627 ankur.sing 12721 
  def read(self, iprot):
12722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12724 
      return
12725 
    iprot.readStructBegin()
12726 
    while True:
12727 
      (fname, ftype, fid) = iprot.readFieldBegin()
12728 
      if ftype == TType.STOP:
12729 
        break
3064 chandransh 12730 
      if fid == 1:
12731 
        if ftype == TType.STRUCT:
12732 
          self.ex = TransactionServiceException()
12733 
          self.ex.read(iprot)
12734 
        else:
12735 
          iprot.skip(ftype)
1627 ankur.sing 12736 
      else:
12737 
        iprot.skip(ftype)
12738 
      iprot.readFieldEnd()
12739 
    iprot.readStructEnd()
12740 
 
12741 
  def write(self, oprot):
12742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12744 
      return
4910 phani.kuma 12745 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12746 
    if self.ex is not None:
3064 chandransh 12747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12748 
      self.ex.write(oprot)
12749 
      oprot.writeFieldEnd()
1627 ankur.sing 12750 
    oprot.writeFieldStop()
12751 
    oprot.writeStructEnd()
12752 
 
3431 rajveer 12753 
  def validate(self):
12754 
    return
12755 
 
12756 
 
1627 ankur.sing 12757 
  def __repr__(self):
12758 
    L = ['%s=%r' % (key, value)
12759 
      for key, value in self.__dict__.iteritems()]
12760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12761 
 
12762 
  def __eq__(self, other):
12763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12764 
 
12765 
  def __ne__(self, other):
12766 
    return not (self == other)
12767 
 
4910 phani.kuma 12768 
class getRTOrders_args:
12769 
  """
12770 
  Attributes:
12771 
   - providerId
12772 
  """
12773 
 
12774 
  thrift_spec = (
12775 
    None, # 0
12776 
    (1, TType.I64, 'providerId', None, None, ), # 1
12777 
  )
12778 
 
12779 
  def __init__(self, providerId=None,):
12780 
    self.providerId = providerId
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      if fid == 1:
12792 
        if ftype == TType.I64:
12793 
          self.providerId = iprot.readI64();
12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      else:
12797 
        iprot.skip(ftype)
12798 
      iprot.readFieldEnd()
12799 
    iprot.readStructEnd()
12800 
 
12801 
  def write(self, oprot):
12802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12804 
      return
12805 
    oprot.writeStructBegin('getRTOrders_args')
12806 
    if self.providerId is not None:
12807 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12808 
      oprot.writeI64(self.providerId)
12809 
      oprot.writeFieldEnd()
12810 
    oprot.writeFieldStop()
12811 
    oprot.writeStructEnd()
12812 
 
12813 
  def validate(self):
12814 
    return
12815 
 
12816 
 
12817 
  def __repr__(self):
12818 
    L = ['%s=%r' % (key, value)
12819 
      for key, value in self.__dict__.iteritems()]
12820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12821 
 
12822 
  def __eq__(self, other):
12823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12824 
 
12825 
  def __ne__(self, other):
12826 
    return not (self == other)
12827 
 
12828 
class getRTOrders_result:
12829 
  """
12830 
  Attributes:
12831 
   - success
12832 
  """
12833 
 
12834 
  thrift_spec = (
12835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12836 
  )
12837 
 
12838 
  def __init__(self, success=None,):
12839 
    self.success = success
12840 
 
12841 
  def read(self, iprot):
12842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12844 
      return
12845 
    iprot.readStructBegin()
12846 
    while True:
12847 
      (fname, ftype, fid) = iprot.readFieldBegin()
12848 
      if ftype == TType.STOP:
12849 
        break
12850 
      if fid == 0:
12851 
        if ftype == TType.LIST:
12852 
          self.success = []
5386 phani.kuma 12853 
          (_etype268, _size265) = iprot.readListBegin()
12854 
          for _i269 in xrange(_size265):
12855 
            _elem270 = Order()
12856 
            _elem270.read(iprot)
12857 
            self.success.append(_elem270)
4910 phani.kuma 12858 
          iprot.readListEnd()
12859 
        else:
12860 
          iprot.skip(ftype)
12861 
      else:
12862 
        iprot.skip(ftype)
12863 
      iprot.readFieldEnd()
12864 
    iprot.readStructEnd()
12865 
 
12866 
  def write(self, oprot):
12867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12869 
      return
12870 
    oprot.writeStructBegin('getRTOrders_result')
12871 
    if self.success is not None:
12872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 12874 
      for iter271 in self.success:
12875 
        iter271.write(oprot)
4910 phani.kuma 12876 
      oprot.writeListEnd()
12877 
      oprot.writeFieldEnd()
12878 
    oprot.writeFieldStop()
12879 
    oprot.writeStructEnd()
12880 
 
12881 
  def validate(self):
12882 
    return
12883 
 
12884 
 
12885 
  def __repr__(self):
12886 
    L = ['%s=%r' % (key, value)
12887 
      for key, value in self.__dict__.iteritems()]
12888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12889 
 
12890 
  def __eq__(self, other):
12891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12892 
 
12893 
  def __ne__(self, other):
12894 
    return not (self == other)
12895 
 
3064 chandransh 12896 
class updateNonDeliveryReason_args:
1627 ankur.sing 12897 
  """
12898 
  Attributes:
3064 chandransh 12899 
   - providerId
12900 
   - undeliveredOrders
1627 ankur.sing 12901 
  """
12902 
 
12903 
  thrift_spec = (
3064 chandransh 12904 
    None, # 0
12905 
    (1, TType.I64, 'providerId', None, None, ), # 1
12906 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12907 
  )
12908 
 
3064 chandransh 12909 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12910 
    self.providerId = providerId
12911 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12912 
 
12913 
  def read(self, iprot):
12914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12916 
      return
12917 
    iprot.readStructBegin()
12918 
    while True:
12919 
      (fname, ftype, fid) = iprot.readFieldBegin()
12920 
      if ftype == TType.STOP:
12921 
        break
3064 chandransh 12922 
      if fid == 1:
1627 ankur.sing 12923 
        if ftype == TType.I64:
3064 chandransh 12924 
          self.providerId = iprot.readI64();
1627 ankur.sing 12925 
        else:
12926 
          iprot.skip(ftype)
3064 chandransh 12927 
      elif fid == 2:
12928 
        if ftype == TType.MAP:
12929 
          self.undeliveredOrders = {}
5386 phani.kuma 12930 
          (_ktype273, _vtype274, _size272 ) = iprot.readMapBegin()
12931 
          for _i276 in xrange(_size272):
12932 
            _key277 = iprot.readString();
12933 
            _val278 = iprot.readString();
12934 
            self.undeliveredOrders[_key277] = _val278
3064 chandransh 12935 
          iprot.readMapEnd()
12936 
        else:
12937 
          iprot.skip(ftype)
1627 ankur.sing 12938 
      else:
12939 
        iprot.skip(ftype)
12940 
      iprot.readFieldEnd()
12941 
    iprot.readStructEnd()
12942 
 
12943 
  def write(self, oprot):
12944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12946 
      return
3064 chandransh 12947 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12948 
    if self.providerId is not None:
3064 chandransh 12949 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12950 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12951 
      oprot.writeFieldEnd()
3431 rajveer 12952 
    if self.undeliveredOrders is not None:
3064 chandransh 12953 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12954 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5386 phani.kuma 12955 
      for kiter279,viter280 in self.undeliveredOrders.items():
12956 
        oprot.writeString(kiter279)
12957 
        oprot.writeString(viter280)
3064 chandransh 12958 
      oprot.writeMapEnd()
12959 
      oprot.writeFieldEnd()
1627 ankur.sing 12960 
    oprot.writeFieldStop()
12961 
    oprot.writeStructEnd()
12962 
 
3431 rajveer 12963 
  def validate(self):
12964 
    return
12965 
 
12966 
 
1627 ankur.sing 12967 
  def __repr__(self):
12968 
    L = ['%s=%r' % (key, value)
12969 
      for key, value in self.__dict__.iteritems()]
12970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12971 
 
12972 
  def __eq__(self, other):
12973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12974 
 
12975 
  def __ne__(self, other):
12976 
    return not (self == other)
12977 
 
3064 chandransh 12978 
class updateNonDeliveryReason_result:
1627 ankur.sing 12979 
  """
12980 
  Attributes:
3064 chandransh 12981 
   - ex
1627 ankur.sing 12982 
  """
12983 
 
12984 
  thrift_spec = (
4910 phani.kuma 12985 
    None, # 0
3064 chandransh 12986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12987 
  )
12988 
 
4910 phani.kuma 12989 
  def __init__(self, ex=None,):
3064 chandransh 12990 
    self.ex = ex
1627 ankur.sing 12991 
 
12992 
  def read(self, iprot):
12993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12995 
      return
12996 
    iprot.readStructBegin()
12997 
    while True:
12998 
      (fname, ftype, fid) = iprot.readFieldBegin()
12999 
      if ftype == TType.STOP:
13000 
        break
4910 phani.kuma 13001 
      if fid == 1:
13002 
        if ftype == TType.STRUCT:
13003 
          self.ex = TransactionServiceException()
13004 
          self.ex.read(iprot)
13005 
        else:
13006 
          iprot.skip(ftype)
13007 
      else:
13008 
        iprot.skip(ftype)
13009 
      iprot.readFieldEnd()
13010 
    iprot.readStructEnd()
13011 
 
13012 
  def write(self, oprot):
13013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13015 
      return
13016 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13017 
    if self.ex is not None:
13018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13019 
      self.ex.write(oprot)
13020 
      oprot.writeFieldEnd()
13021 
    oprot.writeFieldStop()
13022 
    oprot.writeStructEnd()
13023 
 
13024 
  def validate(self):
13025 
    return
13026 
 
13027 
 
13028 
  def __repr__(self):
13029 
    L = ['%s=%r' % (key, value)
13030 
      for key, value in self.__dict__.iteritems()]
13031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13032 
 
13033 
  def __eq__(self, other):
13034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13035 
 
13036 
  def __ne__(self, other):
13037 
    return not (self == other)
13038 
 
13039 
class getNonDeliveredOrdersbyCourier_args:
13040 
  """
13041 
  Attributes:
13042 
   - providerId
13043 
  """
13044 
 
13045 
  thrift_spec = (
13046 
    None, # 0
13047 
    (1, TType.I64, 'providerId', None, None, ), # 1
13048 
  )
13049 
 
13050 
  def __init__(self, providerId=None,):
13051 
    self.providerId = providerId
13052 
 
13053 
  def read(self, iprot):
13054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13056 
      return
13057 
    iprot.readStructBegin()
13058 
    while True:
13059 
      (fname, ftype, fid) = iprot.readFieldBegin()
13060 
      if ftype == TType.STOP:
13061 
        break
13062 
      if fid == 1:
13063 
        if ftype == TType.I64:
13064 
          self.providerId = iprot.readI64();
13065 
        else:
13066 
          iprot.skip(ftype)
13067 
      else:
13068 
        iprot.skip(ftype)
13069 
      iprot.readFieldEnd()
13070 
    iprot.readStructEnd()
13071 
 
13072 
  def write(self, oprot):
13073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13075 
      return
13076 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13077 
    if self.providerId is not None:
13078 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13079 
      oprot.writeI64(self.providerId)
13080 
      oprot.writeFieldEnd()
13081 
    oprot.writeFieldStop()
13082 
    oprot.writeStructEnd()
13083 
 
13084 
  def validate(self):
13085 
    return
13086 
 
13087 
 
13088 
  def __repr__(self):
13089 
    L = ['%s=%r' % (key, value)
13090 
      for key, value in self.__dict__.iteritems()]
13091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13092 
 
13093 
  def __eq__(self, other):
13094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13095 
 
13096 
  def __ne__(self, other):
13097 
    return not (self == other)
13098 
 
13099 
class getNonDeliveredOrdersbyCourier_result:
13100 
  """
13101 
  Attributes:
13102 
   - success
13103 
  """
13104 
 
13105 
  thrift_spec = (
13106 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13107 
  )
13108 
 
13109 
  def __init__(self, success=None,):
13110 
    self.success = success
13111 
 
13112 
  def read(self, iprot):
13113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13115 
      return
13116 
    iprot.readStructBegin()
13117 
    while True:
13118 
      (fname, ftype, fid) = iprot.readFieldBegin()
13119 
      if ftype == TType.STOP:
13120 
        break
4581 phani.kuma 13121 
      if fid == 0:
13122 
        if ftype == TType.LIST:
13123 
          self.success = []
5386 phani.kuma 13124 
          (_etype284, _size281) = iprot.readListBegin()
13125 
          for _i285 in xrange(_size281):
13126 
            _elem286 = Order()
13127 
            _elem286.read(iprot)
13128 
            self.success.append(_elem286)
4581 phani.kuma 13129 
          iprot.readListEnd()
13130 
        else:
13131 
          iprot.skip(ftype)
4910 phani.kuma 13132 
      else:
13133 
        iprot.skip(ftype)
13134 
      iprot.readFieldEnd()
13135 
    iprot.readStructEnd()
13136 
 
13137 
  def write(self, oprot):
13138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13140 
      return
13141 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13142 
    if self.success is not None:
13143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13144 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 13145 
      for iter287 in self.success:
13146 
        iter287.write(oprot)
4910 phani.kuma 13147 
      oprot.writeListEnd()
13148 
      oprot.writeFieldEnd()
13149 
    oprot.writeFieldStop()
13150 
    oprot.writeStructEnd()
13151 
 
13152 
  def validate(self):
13153 
    return
13154 
 
13155 
 
13156 
  def __repr__(self):
13157 
    L = ['%s=%r' % (key, value)
13158 
      for key, value in self.__dict__.iteritems()]
13159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13160 
 
13161 
  def __eq__(self, other):
13162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13163 
 
13164 
  def __ne__(self, other):
13165 
    return not (self == other)
13166 
 
13167 
class markOrdersAsLocalConnected_args:
13168 
  """
13169 
  Attributes:
13170 
   - providerId
13171 
   - local_connected_orders
13172 
  """
13173 
 
13174 
  thrift_spec = (
13175 
    None, # 0
13176 
    (1, TType.I64, 'providerId', None, None, ), # 1
13177 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13178 
  )
13179 
 
13180 
  def __init__(self, providerId=None, local_connected_orders=None,):
13181 
    self.providerId = providerId
13182 
    self.local_connected_orders = local_connected_orders
13183 
 
13184 
  def read(self, iprot):
13185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13187 
      return
13188 
    iprot.readStructBegin()
13189 
    while True:
13190 
      (fname, ftype, fid) = iprot.readFieldBegin()
13191 
      if ftype == TType.STOP:
13192 
        break
13193 
      if fid == 1:
13194 
        if ftype == TType.I64:
13195 
          self.providerId = iprot.readI64();
13196 
        else:
13197 
          iprot.skip(ftype)
13198 
      elif fid == 2:
13199 
        if ftype == TType.MAP:
13200 
          self.local_connected_orders = {}
5386 phani.kuma 13201 
          (_ktype289, _vtype290, _size288 ) = iprot.readMapBegin()
13202 
          for _i292 in xrange(_size288):
13203 
            _key293 = iprot.readString();
13204 
            _val294 = iprot.readString();
13205 
            self.local_connected_orders[_key293] = _val294
4910 phani.kuma 13206 
          iprot.readMapEnd()
13207 
        else:
13208 
          iprot.skip(ftype)
13209 
      else:
13210 
        iprot.skip(ftype)
13211 
      iprot.readFieldEnd()
13212 
    iprot.readStructEnd()
13213 
 
13214 
  def write(self, oprot):
13215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13217 
      return
13218 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13219 
    if self.providerId is not None:
13220 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13221 
      oprot.writeI64(self.providerId)
13222 
      oprot.writeFieldEnd()
13223 
    if self.local_connected_orders is not None:
13224 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13225 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5386 phani.kuma 13226 
      for kiter295,viter296 in self.local_connected_orders.items():
13227 
        oprot.writeString(kiter295)
13228 
        oprot.writeString(viter296)
4910 phani.kuma 13229 
      oprot.writeMapEnd()
13230 
      oprot.writeFieldEnd()
13231 
    oprot.writeFieldStop()
13232 
    oprot.writeStructEnd()
13233 
 
13234 
  def validate(self):
13235 
    return
13236 
 
13237 
 
13238 
  def __repr__(self):
13239 
    L = ['%s=%r' % (key, value)
13240 
      for key, value in self.__dict__.iteritems()]
13241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13242 
 
13243 
  def __eq__(self, other):
13244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13245 
 
13246 
  def __ne__(self, other):
13247 
    return not (self == other)
13248 
 
13249 
class markOrdersAsLocalConnected_result:
13250 
  """
13251 
  Attributes:
13252 
   - ex
13253 
  """
13254 
 
13255 
  thrift_spec = (
13256 
    None, # 0
13257 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13258 
  )
13259 
 
13260 
  def __init__(self, ex=None,):
13261 
    self.ex = ex
13262 
 
13263 
  def read(self, iprot):
13264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13266 
      return
13267 
    iprot.readStructBegin()
13268 
    while True:
13269 
      (fname, ftype, fid) = iprot.readFieldBegin()
13270 
      if ftype == TType.STOP:
13271 
        break
13272 
      if fid == 1:
3064 chandransh 13273 
        if ftype == TType.STRUCT:
13274 
          self.ex = TransactionServiceException()
13275 
          self.ex.read(iprot)
1627 ankur.sing 13276 
        else:
13277 
          iprot.skip(ftype)
13278 
      else:
13279 
        iprot.skip(ftype)
13280 
      iprot.readFieldEnd()
13281 
    iprot.readStructEnd()
13282 
 
13283 
  def write(self, oprot):
13284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13286 
      return
4910 phani.kuma 13287 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13288 
    if self.ex is not None:
13289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13290 
      self.ex.write(oprot)
13291 
      oprot.writeFieldEnd()
13292 
    oprot.writeFieldStop()
13293 
    oprot.writeStructEnd()
13294 
 
13295 
  def validate(self):
13296 
    return
13297 
 
13298 
 
13299 
  def __repr__(self):
13300 
    L = ['%s=%r' % (key, value)
13301 
      for key, value in self.__dict__.iteritems()]
13302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13303 
 
13304 
  def __eq__(self, other):
13305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13306 
 
13307 
  def __ne__(self, other):
13308 
    return not (self == other)
13309 
 
13310 
class getOrdersNotLocalConnected_args:
13311 
  """
13312 
  Attributes:
13313 
   - providerId
13314 
  """
13315 
 
13316 
  thrift_spec = (
13317 
    None, # 0
13318 
    (1, TType.I64, 'providerId', None, None, ), # 1
13319 
  )
13320 
 
13321 
  def __init__(self, providerId=None,):
13322 
    self.providerId = providerId
13323 
 
13324 
  def read(self, iprot):
13325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13327 
      return
13328 
    iprot.readStructBegin()
13329 
    while True:
13330 
      (fname, ftype, fid) = iprot.readFieldBegin()
13331 
      if ftype == TType.STOP:
13332 
        break
13333 
      if fid == 1:
13334 
        if ftype == TType.I64:
13335 
          self.providerId = iprot.readI64();
13336 
        else:
13337 
          iprot.skip(ftype)
13338 
      else:
13339 
        iprot.skip(ftype)
13340 
      iprot.readFieldEnd()
13341 
    iprot.readStructEnd()
13342 
 
13343 
  def write(self, oprot):
13344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13346 
      return
13347 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13348 
    if self.providerId is not None:
13349 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13350 
      oprot.writeI64(self.providerId)
13351 
      oprot.writeFieldEnd()
13352 
    oprot.writeFieldStop()
13353 
    oprot.writeStructEnd()
13354 
 
13355 
  def validate(self):
13356 
    return
13357 
 
13358 
 
13359 
  def __repr__(self):
13360 
    L = ['%s=%r' % (key, value)
13361 
      for key, value in self.__dict__.iteritems()]
13362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13363 
 
13364 
  def __eq__(self, other):
13365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13366 
 
13367 
  def __ne__(self, other):
13368 
    return not (self == other)
13369 
 
13370 
class getOrdersNotLocalConnected_result:
13371 
  """
13372 
  Attributes:
13373 
   - success
13374 
  """
13375 
 
13376 
  thrift_spec = (
13377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13378 
  )
13379 
 
13380 
  def __init__(self, success=None,):
13381 
    self.success = success
13382 
 
13383 
  def read(self, iprot):
13384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13386 
      return
13387 
    iprot.readStructBegin()
13388 
    while True:
13389 
      (fname, ftype, fid) = iprot.readFieldBegin()
13390 
      if ftype == TType.STOP:
13391 
        break
13392 
      if fid == 0:
13393 
        if ftype == TType.LIST:
13394 
          self.success = []
5386 phani.kuma 13395 
          (_etype300, _size297) = iprot.readListBegin()
13396 
          for _i301 in xrange(_size297):
13397 
            _elem302 = Order()
13398 
            _elem302.read(iprot)
13399 
            self.success.append(_elem302)
4910 phani.kuma 13400 
          iprot.readListEnd()
13401 
        else:
13402 
          iprot.skip(ftype)
13403 
      else:
13404 
        iprot.skip(ftype)
13405 
      iprot.readFieldEnd()
13406 
    iprot.readStructEnd()
13407 
 
13408 
  def write(self, oprot):
13409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13411 
      return
13412 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13413 
    if self.success is not None:
13414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 13416 
      for iter303 in self.success:
13417 
        iter303.write(oprot)
4581 phani.kuma 13418 
      oprot.writeListEnd()
13419 
      oprot.writeFieldEnd()
4910 phani.kuma 13420 
    oprot.writeFieldStop()
13421 
    oprot.writeStructEnd()
13422 
 
13423 
  def validate(self):
13424 
    return
13425 
 
13426 
 
13427 
  def __repr__(self):
13428 
    L = ['%s=%r' % (key, value)
13429 
      for key, value in self.__dict__.iteritems()]
13430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13431 
 
13432 
  def __eq__(self, other):
13433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13434 
 
13435 
  def __ne__(self, other):
13436 
    return not (self == other)
13437 
 
13438 
class markOrdersAsDestinationCityReached_args:
13439 
  """
13440 
  Attributes:
13441 
   - providerId
13442 
   - destination_city_reached_orders
13443 
  """
13444 
 
13445 
  thrift_spec = (
13446 
    None, # 0
13447 
    (1, TType.I64, 'providerId', None, None, ), # 1
13448 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13449 
  )
13450 
 
13451 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13452 
    self.providerId = providerId
13453 
    self.destination_city_reached_orders = destination_city_reached_orders
13454 
 
13455 
  def read(self, iprot):
13456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13458 
      return
13459 
    iprot.readStructBegin()
13460 
    while True:
13461 
      (fname, ftype, fid) = iprot.readFieldBegin()
13462 
      if ftype == TType.STOP:
13463 
        break
13464 
      if fid == 1:
13465 
        if ftype == TType.I64:
13466 
          self.providerId = iprot.readI64();
13467 
        else:
13468 
          iprot.skip(ftype)
13469 
      elif fid == 2:
13470 
        if ftype == TType.MAP:
13471 
          self.destination_city_reached_orders = {}
5386 phani.kuma 13472 
          (_ktype305, _vtype306, _size304 ) = iprot.readMapBegin()
13473 
          for _i308 in xrange(_size304):
13474 
            _key309 = iprot.readString();
13475 
            _val310 = iprot.readString();
13476 
            self.destination_city_reached_orders[_key309] = _val310
4910 phani.kuma 13477 
          iprot.readMapEnd()
13478 
        else:
13479 
          iprot.skip(ftype)
13480 
      else:
13481 
        iprot.skip(ftype)
13482 
      iprot.readFieldEnd()
13483 
    iprot.readStructEnd()
13484 
 
13485 
  def write(self, oprot):
13486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13488 
      return
13489 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13490 
    if self.providerId is not None:
13491 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13492 
      oprot.writeI64(self.providerId)
13493 
      oprot.writeFieldEnd()
13494 
    if self.destination_city_reached_orders is not None:
13495 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13496 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5386 phani.kuma 13497 
      for kiter311,viter312 in self.destination_city_reached_orders.items():
13498 
        oprot.writeString(kiter311)
13499 
        oprot.writeString(viter312)
4910 phani.kuma 13500 
      oprot.writeMapEnd()
13501 
      oprot.writeFieldEnd()
13502 
    oprot.writeFieldStop()
13503 
    oprot.writeStructEnd()
13504 
 
13505 
  def validate(self):
13506 
    return
13507 
 
13508 
 
13509 
  def __repr__(self):
13510 
    L = ['%s=%r' % (key, value)
13511 
      for key, value in self.__dict__.iteritems()]
13512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13513 
 
13514 
  def __eq__(self, other):
13515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13516 
 
13517 
  def __ne__(self, other):
13518 
    return not (self == other)
13519 
 
13520 
class markOrdersAsDestinationCityReached_result:
13521 
  """
13522 
  Attributes:
13523 
   - ex
13524 
  """
13525 
 
13526 
  thrift_spec = (
13527 
    None, # 0
13528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13529 
  )
13530 
 
13531 
  def __init__(self, ex=None,):
13532 
    self.ex = ex
13533 
 
13534 
  def read(self, iprot):
13535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13537 
      return
13538 
    iprot.readStructBegin()
13539 
    while True:
13540 
      (fname, ftype, fid) = iprot.readFieldBegin()
13541 
      if ftype == TType.STOP:
13542 
        break
13543 
      if fid == 1:
13544 
        if ftype == TType.STRUCT:
13545 
          self.ex = TransactionServiceException()
13546 
          self.ex.read(iprot)
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
13558 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13559 
    if self.ex is not None:
3064 chandransh 13560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13561 
      self.ex.write(oprot)
1627 ankur.sing 13562 
      oprot.writeFieldEnd()
13563 
    oprot.writeFieldStop()
13564 
    oprot.writeStructEnd()
13565 
 
3431 rajveer 13566 
  def validate(self):
13567 
    return
13568 
 
13569 
 
1627 ankur.sing 13570 
  def __repr__(self):
13571 
    L = ['%s=%r' % (key, value)
13572 
      for key, value in self.__dict__.iteritems()]
13573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13574 
 
13575 
  def __eq__(self, other):
13576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13577 
 
13578 
  def __ne__(self, other):
13579 
    return not (self == other)
13580 
 
4910 phani.kuma 13581 
class markOrdersAsFirstDeliveryAttempted_args:
13582 
  """
13583 
  Attributes:
13584 
   - providerId
13585 
   - first_atdl_orders
13586 
  """
13587 
 
13588 
  thrift_spec = (
13589 
    None, # 0
13590 
    (1, TType.I64, 'providerId', None, None, ), # 1
13591 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13592 
  )
13593 
 
13594 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13595 
    self.providerId = providerId
13596 
    self.first_atdl_orders = first_atdl_orders
13597 
 
13598 
  def read(self, iprot):
13599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13601 
      return
13602 
    iprot.readStructBegin()
13603 
    while True:
13604 
      (fname, ftype, fid) = iprot.readFieldBegin()
13605 
      if ftype == TType.STOP:
13606 
        break
13607 
      if fid == 1:
13608 
        if ftype == TType.I64:
13609 
          self.providerId = iprot.readI64();
13610 
        else:
13611 
          iprot.skip(ftype)
13612 
      elif fid == 2:
13613 
        if ftype == TType.MAP:
13614 
          self.first_atdl_orders = {}
5386 phani.kuma 13615 
          (_ktype314, _vtype315, _size313 ) = iprot.readMapBegin()
13616 
          for _i317 in xrange(_size313):
13617 
            _key318 = iprot.readString();
13618 
            _val319 = iprot.readString();
13619 
            self.first_atdl_orders[_key318] = _val319
4910 phani.kuma 13620 
          iprot.readMapEnd()
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      else:
13624 
        iprot.skip(ftype)
13625 
      iprot.readFieldEnd()
13626 
    iprot.readStructEnd()
13627 
 
13628 
  def write(self, oprot):
13629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13631 
      return
13632 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13633 
    if self.providerId is not None:
13634 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13635 
      oprot.writeI64(self.providerId)
13636 
      oprot.writeFieldEnd()
13637 
    if self.first_atdl_orders is not None:
13638 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13639 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5386 phani.kuma 13640 
      for kiter320,viter321 in self.first_atdl_orders.items():
13641 
        oprot.writeString(kiter320)
13642 
        oprot.writeString(viter321)
4910 phani.kuma 13643 
      oprot.writeMapEnd()
13644 
      oprot.writeFieldEnd()
13645 
    oprot.writeFieldStop()
13646 
    oprot.writeStructEnd()
13647 
 
13648 
  def validate(self):
13649 
    return
13650 
 
13651 
 
13652 
  def __repr__(self):
13653 
    L = ['%s=%r' % (key, value)
13654 
      for key, value in self.__dict__.iteritems()]
13655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13656 
 
13657 
  def __eq__(self, other):
13658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13659 
 
13660 
  def __ne__(self, other):
13661 
    return not (self == other)
13662 
 
13663 
class markOrdersAsFirstDeliveryAttempted_result:
13664 
  """
13665 
  Attributes:
13666 
   - ex
13667 
  """
13668 
 
13669 
  thrift_spec = (
13670 
    None, # 0
13671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13672 
  )
13673 
 
13674 
  def __init__(self, ex=None,):
13675 
    self.ex = ex
13676 
 
13677 
  def read(self, iprot):
13678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13680 
      return
13681 
    iprot.readStructBegin()
13682 
    while True:
13683 
      (fname, ftype, fid) = iprot.readFieldBegin()
13684 
      if ftype == TType.STOP:
13685 
        break
13686 
      if fid == 1:
13687 
        if ftype == TType.STRUCT:
13688 
          self.ex = TransactionServiceException()
13689 
          self.ex.read(iprot)
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      else:
13693 
        iprot.skip(ftype)
13694 
      iprot.readFieldEnd()
13695 
    iprot.readStructEnd()
13696 
 
13697 
  def write(self, oprot):
13698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13700 
      return
13701 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13702 
    if self.ex is not None:
13703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13704 
      self.ex.write(oprot)
13705 
      oprot.writeFieldEnd()
13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
3064 chandransh 13724 
class getUndeliveredOrders_args:
1886 ankur.sing 13725 
  """
13726 
  Attributes:
3064 chandransh 13727 
   - providerId
13728 
   - warehouseId
1886 ankur.sing 13729 
  """
1627 ankur.sing 13730 
 
1886 ankur.sing 13731 
  thrift_spec = (
13732 
    None, # 0
3064 chandransh 13733 
    (1, TType.I64, 'providerId', None, None, ), # 1
13734 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13735 
  )
13736 
 
3064 chandransh 13737 
  def __init__(self, providerId=None, warehouseId=None,):
13738 
    self.providerId = providerId
13739 
    self.warehouseId = warehouseId
1886 ankur.sing 13740 
 
13741 
  def read(self, iprot):
13742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13744 
      return
13745 
    iprot.readStructBegin()
13746 
    while True:
13747 
      (fname, ftype, fid) = iprot.readFieldBegin()
13748 
      if ftype == TType.STOP:
13749 
        break
13750 
      if fid == 1:
13751 
        if ftype == TType.I64:
3064 chandransh 13752 
          self.providerId = iprot.readI64();
1886 ankur.sing 13753 
        else:
13754 
          iprot.skip(ftype)
3064 chandransh 13755 
      elif fid == 2:
13756 
        if ftype == TType.I64:
13757 
          self.warehouseId = iprot.readI64();
13758 
        else:
13759 
          iprot.skip(ftype)
1886 ankur.sing 13760 
      else:
13761 
        iprot.skip(ftype)
13762 
      iprot.readFieldEnd()
13763 
    iprot.readStructEnd()
13764 
 
13765 
  def write(self, oprot):
13766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13768 
      return
3064 chandransh 13769 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13770 
    if self.providerId is not None:
3064 chandransh 13771 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13772 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13773 
      oprot.writeFieldEnd()
3431 rajveer 13774 
    if self.warehouseId is not None:
3064 chandransh 13775 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13776 
      oprot.writeI64(self.warehouseId)
13777 
      oprot.writeFieldEnd()
1886 ankur.sing 13778 
    oprot.writeFieldStop()
13779 
    oprot.writeStructEnd()
13780 
 
3431 rajveer 13781 
  def validate(self):
13782 
    return
13783 
 
13784 
 
1886 ankur.sing 13785 
  def __repr__(self):
13786 
    L = ['%s=%r' % (key, value)
13787 
      for key, value in self.__dict__.iteritems()]
13788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13789 
 
13790 
  def __eq__(self, other):
13791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13792 
 
13793 
  def __ne__(self, other):
13794 
    return not (self == other)
13795 
 
3064 chandransh 13796 
class getUndeliveredOrders_result:
1886 ankur.sing 13797 
  """
13798 
  Attributes:
13799 
   - success
13800 
  """
13801 
 
13802 
  thrift_spec = (
13803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13804 
  )
13805 
 
13806 
  def __init__(self, success=None,):
13807 
    self.success = success
13808 
 
13809 
  def read(self, iprot):
13810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13812 
      return
13813 
    iprot.readStructBegin()
13814 
    while True:
13815 
      (fname, ftype, fid) = iprot.readFieldBegin()
13816 
      if ftype == TType.STOP:
13817 
        break
13818 
      if fid == 0:
13819 
        if ftype == TType.LIST:
13820 
          self.success = []
5386 phani.kuma 13821 
          (_etype325, _size322) = iprot.readListBegin()
13822 
          for _i326 in xrange(_size322):
13823 
            _elem327 = Order()
13824 
            _elem327.read(iprot)
13825 
            self.success.append(_elem327)
1886 ankur.sing 13826 
          iprot.readListEnd()
13827 
        else:
13828 
          iprot.skip(ftype)
13829 
      else:
13830 
        iprot.skip(ftype)
13831 
      iprot.readFieldEnd()
13832 
    iprot.readStructEnd()
13833 
 
13834 
  def write(self, oprot):
13835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13837 
      return
3064 chandransh 13838 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13839 
    if self.success is not None:
1886 ankur.sing 13840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 13842 
      for iter328 in self.success:
13843 
        iter328.write(oprot)
1886 ankur.sing 13844 
      oprot.writeListEnd()
13845 
      oprot.writeFieldEnd()
13846 
    oprot.writeFieldStop()
13847 
    oprot.writeStructEnd()
13848 
 
3431 rajveer 13849 
  def validate(self):
13850 
    return
13851 
 
13852 
 
1886 ankur.sing 13853 
  def __repr__(self):
13854 
    L = ['%s=%r' % (key, value)
13855 
      for key, value in self.__dict__.iteritems()]
13856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13857 
 
13858 
  def __eq__(self, other):
13859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13860 
 
13861 
  def __ne__(self, other):
13862 
    return not (self == other)
13863 
 
4783 phani.kuma 13864 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13865 
 
13866 
  thrift_spec = (
13867 
  )
13868 
 
13869 
  def read(self, iprot):
13870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13872 
      return
13873 
    iprot.readStructBegin()
13874 
    while True:
13875 
      (fname, ftype, fid) = iprot.readFieldBegin()
13876 
      if ftype == TType.STOP:
13877 
        break
13878 
      else:
13879 
        iprot.skip(ftype)
13880 
      iprot.readFieldEnd()
13881 
    iprot.readStructEnd()
13882 
 
13883 
  def write(self, oprot):
13884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13886 
      return
13887 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13888 
    oprot.writeFieldStop()
13889 
    oprot.writeStructEnd()
13890 
 
13891 
  def validate(self):
13892 
    return
13893 
 
13894 
 
13895 
  def __repr__(self):
13896 
    L = ['%s=%r' % (key, value)
13897 
      for key, value in self.__dict__.iteritems()]
13898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13899 
 
13900 
  def __eq__(self, other):
13901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13902 
 
13903 
  def __ne__(self, other):
13904 
    return not (self == other)
13905 
 
13906 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13907 
  """
13908 
  Attributes:
13909 
   - success
13910 
  """
13911 
 
13912 
  thrift_spec = (
13913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13914 
  )
13915 
 
13916 
  def __init__(self, success=None,):
13917 
    self.success = success
13918 
 
13919 
  def read(self, iprot):
13920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13922 
      return
13923 
    iprot.readStructBegin()
13924 
    while True:
13925 
      (fname, ftype, fid) = iprot.readFieldBegin()
13926 
      if ftype == TType.STOP:
13927 
        break
13928 
      if fid == 0:
13929 
        if ftype == TType.LIST:
13930 
          self.success = []
5386 phani.kuma 13931 
          (_etype332, _size329) = iprot.readListBegin()
13932 
          for _i333 in xrange(_size329):
13933 
            _elem334 = Order()
13934 
            _elem334.read(iprot)
13935 
            self.success.append(_elem334)
4783 phani.kuma 13936 
          iprot.readListEnd()
13937 
        else:
13938 
          iprot.skip(ftype)
13939 
      else:
13940 
        iprot.skip(ftype)
13941 
      iprot.readFieldEnd()
13942 
    iprot.readStructEnd()
13943 
 
13944 
  def write(self, oprot):
13945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13947 
      return
13948 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13949 
    if self.success is not None:
13950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 13952 
      for iter335 in self.success:
13953 
        iter335.write(oprot)
4783 phani.kuma 13954 
      oprot.writeListEnd()
13955 
      oprot.writeFieldEnd()
13956 
    oprot.writeFieldStop()
13957 
    oprot.writeStructEnd()
13958 
 
13959 
  def validate(self):
13960 
    return
13961 
 
13962 
 
13963 
  def __repr__(self):
13964 
    L = ['%s=%r' % (key, value)
13965 
      for key, value in self.__dict__.iteritems()]
13966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13967 
 
13968 
  def __eq__(self, other):
13969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13970 
 
13971 
  def __ne__(self, other):
13972 
    return not (self == other)
13973 
 
2536 chandransh 13974 
class toggleDOAFlag_args:
13975 
  """
13976 
  Attributes:
13977 
   - orderId
13978 
  """
1886 ankur.sing 13979 
 
2536 chandransh 13980 
  thrift_spec = (
13981 
    None, # 0
13982 
    (1, TType.I64, 'orderId', None, None, ), # 1
13983 
  )
13984 
 
13985 
  def __init__(self, orderId=None,):
13986 
    self.orderId = orderId
13987 
 
13988 
  def read(self, iprot):
13989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13991 
      return
13992 
    iprot.readStructBegin()
13993 
    while True:
13994 
      (fname, ftype, fid) = iprot.readFieldBegin()
13995 
      if ftype == TType.STOP:
13996 
        break
13997 
      if fid == 1:
13998 
        if ftype == TType.I64:
13999 
          self.orderId = iprot.readI64();
14000 
        else:
14001 
          iprot.skip(ftype)
14002 
      else:
14003 
        iprot.skip(ftype)
14004 
      iprot.readFieldEnd()
14005 
    iprot.readStructEnd()
14006 
 
14007 
  def write(self, oprot):
14008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14010 
      return
14011 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14012 
    if self.orderId is not None:
2536 chandransh 14013 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14014 
      oprot.writeI64(self.orderId)
14015 
      oprot.writeFieldEnd()
14016 
    oprot.writeFieldStop()
14017 
    oprot.writeStructEnd()
14018 
 
3431 rajveer 14019 
  def validate(self):
14020 
    return
14021 
 
14022 
 
2536 chandransh 14023 
  def __repr__(self):
14024 
    L = ['%s=%r' % (key, value)
14025 
      for key, value in self.__dict__.iteritems()]
14026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14027 
 
14028 
  def __eq__(self, other):
14029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14030 
 
14031 
  def __ne__(self, other):
14032 
    return not (self == other)
14033 
 
14034 
class toggleDOAFlag_result:
14035 
  """
14036 
  Attributes:
14037 
   - success
14038 
   - ex
14039 
  """
14040 
 
14041 
  thrift_spec = (
14042 
    (0, TType.BOOL, 'success', None, None, ), # 0
14043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14044 
  )
14045 
 
14046 
  def __init__(self, success=None, ex=None,):
14047 
    self.success = success
14048 
    self.ex = ex
14049 
 
14050 
  def read(self, iprot):
14051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14053 
      return
14054 
    iprot.readStructBegin()
14055 
    while True:
14056 
      (fname, ftype, fid) = iprot.readFieldBegin()
14057 
      if ftype == TType.STOP:
14058 
        break
14059 
      if fid == 0:
14060 
        if ftype == TType.BOOL:
14061 
          self.success = iprot.readBool();
14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      elif fid == 1:
14065 
        if ftype == TType.STRUCT:
14066 
          self.ex = TransactionServiceException()
14067 
          self.ex.read(iprot)
14068 
        else:
14069 
          iprot.skip(ftype)
14070 
      else:
14071 
        iprot.skip(ftype)
14072 
      iprot.readFieldEnd()
14073 
    iprot.readStructEnd()
14074 
 
14075 
  def write(self, oprot):
14076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14078 
      return
14079 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14080 
    if self.success is not None:
2536 chandransh 14081 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14082 
      oprot.writeBool(self.success)
14083 
      oprot.writeFieldEnd()
3431 rajveer 14084 
    if self.ex is not None:
2536 chandransh 14085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14086 
      self.ex.write(oprot)
14087 
      oprot.writeFieldEnd()
14088 
    oprot.writeFieldStop()
14089 
    oprot.writeStructEnd()
14090 
 
3431 rajveer 14091 
  def validate(self):
14092 
    return
14093 
 
14094 
 
2536 chandransh 14095 
  def __repr__(self):
14096 
    L = ['%s=%r' % (key, value)
14097 
      for key, value in self.__dict__.iteritems()]
14098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14099 
 
14100 
  def __eq__(self, other):
14101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14102 
 
14103 
  def __ne__(self, other):
14104 
    return not (self == other)
14105 
 
4712 rajveer 14106 
class markOrderAsDelivered_args:
14107 
  """
14108 
  Attributes:
14109 
   - orderId
14110 
   - deliveryTimestamp
14111 
   - receiver
14112 
  """
14113 
 
14114 
  thrift_spec = None
14115 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14116 
    self.orderId = orderId
14117 
    self.deliveryTimestamp = deliveryTimestamp
14118 
    self.receiver = receiver
14119 
 
14120 
  def read(self, iprot):
14121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14123 
      return
14124 
    iprot.readStructBegin()
14125 
    while True:
14126 
      (fname, ftype, fid) = iprot.readFieldBegin()
14127 
      if ftype == TType.STOP:
14128 
        break
14129 
      if fid == 1:
14130 
        if ftype == TType.I64:
14131 
          self.orderId = iprot.readI64();
14132 
        else:
14133 
          iprot.skip(ftype)
14134 
      elif fid == 2:
14135 
        if ftype == TType.I64:
14136 
          self.deliveryTimestamp = iprot.readI64();
14137 
        else:
14138 
          iprot.skip(ftype)
14139 
      elif fid == -1:
14140 
        if ftype == TType.STRING:
14141 
          self.receiver = iprot.readString();
14142 
        else:
14143 
          iprot.skip(ftype)
14144 
      else:
14145 
        iprot.skip(ftype)
14146 
      iprot.readFieldEnd()
14147 
    iprot.readStructEnd()
14148 
 
14149 
  def write(self, oprot):
14150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14152 
      return
14153 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14154 
    if self.receiver is not None:
14155 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14156 
      oprot.writeString(self.receiver)
14157 
      oprot.writeFieldEnd()
14158 
    if self.orderId is not None:
14159 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14160 
      oprot.writeI64(self.orderId)
14161 
      oprot.writeFieldEnd()
14162 
    if self.deliveryTimestamp is not None:
14163 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14164 
      oprot.writeI64(self.deliveryTimestamp)
14165 
      oprot.writeFieldEnd()
14166 
    oprot.writeFieldStop()
14167 
    oprot.writeStructEnd()
14168 
 
14169 
  def validate(self):
14170 
    return
14171 
 
14172 
 
14173 
  def __repr__(self):
14174 
    L = ['%s=%r' % (key, value)
14175 
      for key, value in self.__dict__.iteritems()]
14176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14177 
 
14178 
  def __eq__(self, other):
14179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14180 
 
14181 
  def __ne__(self, other):
14182 
    return not (self == other)
14183 
 
14184 
class markOrderAsDelivered_result:
14185 
  """
14186 
  Attributes:
14187 
   - ex
14188 
  """
14189 
 
14190 
  thrift_spec = (
14191 
    None, # 0
14192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14193 
  )
14194 
 
14195 
  def __init__(self, ex=None,):
14196 
    self.ex = ex
14197 
 
14198 
  def read(self, iprot):
14199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14201 
      return
14202 
    iprot.readStructBegin()
14203 
    while True:
14204 
      (fname, ftype, fid) = iprot.readFieldBegin()
14205 
      if ftype == TType.STOP:
14206 
        break
14207 
      if fid == 1:
14208 
        if ftype == TType.STRUCT:
14209 
          self.ex = TransactionServiceException()
14210 
          self.ex.read(iprot)
14211 
        else:
14212 
          iprot.skip(ftype)
14213 
      else:
14214 
        iprot.skip(ftype)
14215 
      iprot.readFieldEnd()
14216 
    iprot.readStructEnd()
14217 
 
14218 
  def write(self, oprot):
14219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14221 
      return
14222 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14223 
    if self.ex is not None:
14224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14225 
      self.ex.write(oprot)
14226 
      oprot.writeFieldEnd()
14227 
    oprot.writeFieldStop()
14228 
    oprot.writeStructEnd()
14229 
 
14230 
  def validate(self):
14231 
    return
14232 
 
14233 
 
14234 
  def __repr__(self):
14235 
    L = ['%s=%r' % (key, value)
14236 
      for key, value in self.__dict__.iteritems()]
14237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14238 
 
14239 
  def __eq__(self, other):
14240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14241 
 
14242 
  def __ne__(self, other):
14243 
    return not (self == other)
14244 
 
4454 rajveer 14245 
class markOrderDoaRequestReceived_args:
14246 
  """
14247 
  Attributes:
14248 
   - orderId
14249 
  """
14250 
 
14251 
  thrift_spec = (
14252 
    None, # 0
14253 
    (1, TType.I64, 'orderId', None, None, ), # 1
14254 
  )
14255 
 
14256 
  def __init__(self, orderId=None,):
14257 
    self.orderId = orderId
14258 
 
14259 
  def read(self, iprot):
14260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14262 
      return
14263 
    iprot.readStructBegin()
14264 
    while True:
14265 
      (fname, ftype, fid) = iprot.readFieldBegin()
14266 
      if ftype == TType.STOP:
14267 
        break
14268 
      if fid == 1:
14269 
        if ftype == TType.I64:
14270 
          self.orderId = iprot.readI64();
14271 
        else:
14272 
          iprot.skip(ftype)
14273 
      else:
14274 
        iprot.skip(ftype)
14275 
      iprot.readFieldEnd()
14276 
    iprot.readStructEnd()
14277 
 
14278 
  def write(self, oprot):
14279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14281 
      return
14282 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14283 
    if self.orderId is not None:
14284 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14285 
      oprot.writeI64(self.orderId)
14286 
      oprot.writeFieldEnd()
14287 
    oprot.writeFieldStop()
14288 
    oprot.writeStructEnd()
14289 
 
14290 
  def validate(self):
14291 
    return
14292 
 
14293 
 
14294 
  def __repr__(self):
14295 
    L = ['%s=%r' % (key, value)
14296 
      for key, value in self.__dict__.iteritems()]
14297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14298 
 
14299 
  def __eq__(self, other):
14300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14301 
 
14302 
  def __ne__(self, other):
14303 
    return not (self == other)
14304 
 
14305 
class markOrderDoaRequestReceived_result:
14306 
  """
14307 
  Attributes:
14308 
   - success
14309 
   - ex
14310 
  """
14311 
 
14312 
  thrift_spec = (
14313 
    (0, TType.BOOL, 'success', None, None, ), # 0
14314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14315 
  )
14316 
 
14317 
  def __init__(self, success=None, ex=None,):
14318 
    self.success = success
14319 
    self.ex = ex
14320 
 
14321 
  def read(self, iprot):
14322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14324 
      return
14325 
    iprot.readStructBegin()
14326 
    while True:
14327 
      (fname, ftype, fid) = iprot.readFieldBegin()
14328 
      if ftype == TType.STOP:
14329 
        break
14330 
      if fid == 0:
14331 
        if ftype == TType.BOOL:
14332 
          self.success = iprot.readBool();
14333 
        else:
14334 
          iprot.skip(ftype)
14335 
      elif fid == 1:
14336 
        if ftype == TType.STRUCT:
14337 
          self.ex = TransactionServiceException()
14338 
          self.ex.read(iprot)
14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      else:
14342 
        iprot.skip(ftype)
14343 
      iprot.readFieldEnd()
14344 
    iprot.readStructEnd()
14345 
 
14346 
  def write(self, oprot):
14347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14349 
      return
14350 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14351 
    if self.success is not None:
14352 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14353 
      oprot.writeBool(self.success)
14354 
      oprot.writeFieldEnd()
14355 
    if self.ex is not None:
14356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14357 
      self.ex.write(oprot)
14358 
      oprot.writeFieldEnd()
14359 
    oprot.writeFieldStop()
14360 
    oprot.writeStructEnd()
14361 
 
14362 
  def validate(self):
14363 
    return
14364 
 
14365 
 
14366 
  def __repr__(self):
14367 
    L = ['%s=%r' % (key, value)
14368 
      for key, value in self.__dict__.iteritems()]
14369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14370 
 
14371 
  def __eq__(self, other):
14372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14373 
 
14374 
  def __ne__(self, other):
14375 
    return not (self == other)
14376 
 
14377 
class markOrderDoaRequestAuthorized_args:
14378 
  """
14379 
  Attributes:
14380 
   - orderId
14381 
   - isAuthorized
14382 
  """
14383 
 
14384 
  thrift_spec = (
14385 
    None, # 0
14386 
    (1, TType.I64, 'orderId', None, None, ), # 1
14387 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14388 
  )
14389 
 
14390 
  def __init__(self, orderId=None, isAuthorized=None,):
14391 
    self.orderId = orderId
14392 
    self.isAuthorized = isAuthorized
14393 
 
14394 
  def read(self, iprot):
14395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14397 
      return
14398 
    iprot.readStructBegin()
14399 
    while True:
14400 
      (fname, ftype, fid) = iprot.readFieldBegin()
14401 
      if ftype == TType.STOP:
14402 
        break
14403 
      if fid == 1:
14404 
        if ftype == TType.I64:
14405 
          self.orderId = iprot.readI64();
14406 
        else:
14407 
          iprot.skip(ftype)
14408 
      elif fid == 2:
14409 
        if ftype == TType.BOOL:
14410 
          self.isAuthorized = iprot.readBool();
14411 
        else:
14412 
          iprot.skip(ftype)
14413 
      else:
14414 
        iprot.skip(ftype)
14415 
      iprot.readFieldEnd()
14416 
    iprot.readStructEnd()
14417 
 
14418 
  def write(self, oprot):
14419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14421 
      return
14422 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14423 
    if self.orderId is not None:
14424 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14425 
      oprot.writeI64(self.orderId)
14426 
      oprot.writeFieldEnd()
14427 
    if self.isAuthorized is not None:
14428 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14429 
      oprot.writeBool(self.isAuthorized)
14430 
      oprot.writeFieldEnd()
14431 
    oprot.writeFieldStop()
14432 
    oprot.writeStructEnd()
14433 
 
14434 
  def validate(self):
14435 
    return
14436 
 
14437 
 
14438 
  def __repr__(self):
14439 
    L = ['%s=%r' % (key, value)
14440 
      for key, value in self.__dict__.iteritems()]
14441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14442 
 
14443 
  def __eq__(self, other):
14444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14445 
 
14446 
  def __ne__(self, other):
14447 
    return not (self == other)
14448 
 
14449 
class markOrderDoaRequestAuthorized_result:
14450 
  """
14451 
  Attributes:
14452 
   - success
14453 
   - ex
14454 
  """
14455 
 
14456 
  thrift_spec = (
14457 
    (0, TType.BOOL, 'success', None, None, ), # 0
14458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14459 
  )
14460 
 
14461 
  def __init__(self, success=None, ex=None,):
14462 
    self.success = success
14463 
    self.ex = ex
14464 
 
14465 
  def read(self, iprot):
14466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14468 
      return
14469 
    iprot.readStructBegin()
14470 
    while True:
14471 
      (fname, ftype, fid) = iprot.readFieldBegin()
14472 
      if ftype == TType.STOP:
14473 
        break
14474 
      if fid == 0:
14475 
        if ftype == TType.BOOL:
14476 
          self.success = iprot.readBool();
14477 
        else:
14478 
          iprot.skip(ftype)
14479 
      elif fid == 1:
14480 
        if ftype == TType.STRUCT:
14481 
          self.ex = TransactionServiceException()
14482 
          self.ex.read(iprot)
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
14494 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14495 
    if self.success is not None:
14496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14497 
      oprot.writeBool(self.success)
14498 
      oprot.writeFieldEnd()
14499 
    if self.ex is not None:
14500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14501 
      self.ex.write(oprot)
14502 
      oprot.writeFieldEnd()
14503 
    oprot.writeFieldStop()
14504 
    oprot.writeStructEnd()
14505 
 
14506 
  def validate(self):
14507 
    return
14508 
 
14509 
 
14510 
  def __repr__(self):
14511 
    L = ['%s=%r' % (key, value)
14512 
      for key, value in self.__dict__.iteritems()]
14513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14514 
 
14515 
  def __eq__(self, other):
14516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14517 
 
14518 
  def __ne__(self, other):
14519 
    return not (self == other)
14520 
 
4488 rajveer 14521 
class markOrderReturnRequestReceived_args:
14522 
  """
14523 
  Attributes:
14524 
   - orderId
14525 
  """
14526 
 
14527 
  thrift_spec = (
14528 
    None, # 0
14529 
    (1, TType.I64, 'orderId', None, None, ), # 1
14530 
  )
14531 
 
14532 
  def __init__(self, orderId=None,):
14533 
    self.orderId = orderId
14534 
 
14535 
  def read(self, iprot):
14536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14538 
      return
14539 
    iprot.readStructBegin()
14540 
    while True:
14541 
      (fname, ftype, fid) = iprot.readFieldBegin()
14542 
      if ftype == TType.STOP:
14543 
        break
14544 
      if fid == 1:
14545 
        if ftype == TType.I64:
14546 
          self.orderId = iprot.readI64();
14547 
        else:
14548 
          iprot.skip(ftype)
14549 
      else:
14550 
        iprot.skip(ftype)
14551 
      iprot.readFieldEnd()
14552 
    iprot.readStructEnd()
14553 
 
14554 
  def write(self, oprot):
14555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14557 
      return
14558 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14559 
    if self.orderId is not None:
14560 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14561 
      oprot.writeI64(self.orderId)
14562 
      oprot.writeFieldEnd()
14563 
    oprot.writeFieldStop()
14564 
    oprot.writeStructEnd()
14565 
 
14566 
  def validate(self):
14567 
    return
14568 
 
14569 
 
14570 
  def __repr__(self):
14571 
    L = ['%s=%r' % (key, value)
14572 
      for key, value in self.__dict__.iteritems()]
14573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14574 
 
14575 
  def __eq__(self, other):
14576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14577 
 
14578 
  def __ne__(self, other):
14579 
    return not (self == other)
14580 
 
14581 
class markOrderReturnRequestReceived_result:
14582 
  """
14583 
  Attributes:
14584 
   - success
14585 
   - ex
14586 
  """
14587 
 
14588 
  thrift_spec = (
14589 
    (0, TType.BOOL, 'success', None, None, ), # 0
14590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14591 
  )
14592 
 
14593 
  def __init__(self, success=None, ex=None,):
14594 
    self.success = success
14595 
    self.ex = ex
14596 
 
14597 
  def read(self, iprot):
14598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14600 
      return
14601 
    iprot.readStructBegin()
14602 
    while True:
14603 
      (fname, ftype, fid) = iprot.readFieldBegin()
14604 
      if ftype == TType.STOP:
14605 
        break
14606 
      if fid == 0:
14607 
        if ftype == TType.BOOL:
14608 
          self.success = iprot.readBool();
14609 
        else:
14610 
          iprot.skip(ftype)
14611 
      elif fid == 1:
14612 
        if ftype == TType.STRUCT:
14613 
          self.ex = TransactionServiceException()
14614 
          self.ex.read(iprot)
14615 
        else:
14616 
          iprot.skip(ftype)
14617 
      else:
14618 
        iprot.skip(ftype)
14619 
      iprot.readFieldEnd()
14620 
    iprot.readStructEnd()
14621 
 
14622 
  def write(self, oprot):
14623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14625 
      return
14626 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14627 
    if self.success is not None:
14628 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14629 
      oprot.writeBool(self.success)
14630 
      oprot.writeFieldEnd()
14631 
    if self.ex is not None:
14632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14633 
      self.ex.write(oprot)
14634 
      oprot.writeFieldEnd()
14635 
    oprot.writeFieldStop()
14636 
    oprot.writeStructEnd()
14637 
 
14638 
  def validate(self):
14639 
    return
14640 
 
14641 
 
14642 
  def __repr__(self):
14643 
    L = ['%s=%r' % (key, value)
14644 
      for key, value in self.__dict__.iteritems()]
14645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14646 
 
14647 
  def __eq__(self, other):
14648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14649 
 
14650 
  def __ne__(self, other):
14651 
    return not (self == other)
14652 
 
14653 
class markOrderReturnRequestAuthorized_args:
14654 
  """
14655 
  Attributes:
14656 
   - orderId
14657 
   - isAuthorized
14658 
  """
14659 
 
14660 
  thrift_spec = (
14661 
    None, # 0
14662 
    (1, TType.I64, 'orderId', None, None, ), # 1
14663 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14664 
  )
14665 
 
14666 
  def __init__(self, orderId=None, isAuthorized=None,):
14667 
    self.orderId = orderId
14668 
    self.isAuthorized = isAuthorized
14669 
 
14670 
  def read(self, iprot):
14671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14673 
      return
14674 
    iprot.readStructBegin()
14675 
    while True:
14676 
      (fname, ftype, fid) = iprot.readFieldBegin()
14677 
      if ftype == TType.STOP:
14678 
        break
14679 
      if fid == 1:
14680 
        if ftype == TType.I64:
14681 
          self.orderId = iprot.readI64();
14682 
        else:
14683 
          iprot.skip(ftype)
14684 
      elif fid == 2:
14685 
        if ftype == TType.BOOL:
14686 
          self.isAuthorized = iprot.readBool();
14687 
        else:
14688 
          iprot.skip(ftype)
14689 
      else:
14690 
        iprot.skip(ftype)
14691 
      iprot.readFieldEnd()
14692 
    iprot.readStructEnd()
14693 
 
14694 
  def write(self, oprot):
14695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14697 
      return
14698 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14699 
    if self.orderId is not None:
14700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14701 
      oprot.writeI64(self.orderId)
14702 
      oprot.writeFieldEnd()
14703 
    if self.isAuthorized is not None:
14704 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14705 
      oprot.writeBool(self.isAuthorized)
14706 
      oprot.writeFieldEnd()
14707 
    oprot.writeFieldStop()
14708 
    oprot.writeStructEnd()
14709 
 
14710 
  def validate(self):
14711 
    return
14712 
 
14713 
 
14714 
  def __repr__(self):
14715 
    L = ['%s=%r' % (key, value)
14716 
      for key, value in self.__dict__.iteritems()]
14717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14718 
 
14719 
  def __eq__(self, other):
14720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14721 
 
14722 
  def __ne__(self, other):
14723 
    return not (self == other)
14724 
 
14725 
class markOrderReturnRequestAuthorized_result:
14726 
  """
14727 
  Attributes:
14728 
   - success
14729 
   - ex
14730 
  """
14731 
 
14732 
  thrift_spec = (
14733 
    (0, TType.BOOL, 'success', None, None, ), # 0
14734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14735 
  )
14736 
 
14737 
  def __init__(self, success=None, ex=None,):
14738 
    self.success = success
14739 
    self.ex = ex
14740 
 
14741 
  def read(self, iprot):
14742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14744 
      return
14745 
    iprot.readStructBegin()
14746 
    while True:
14747 
      (fname, ftype, fid) = iprot.readFieldBegin()
14748 
      if ftype == TType.STOP:
14749 
        break
14750 
      if fid == 0:
14751 
        if ftype == TType.BOOL:
14752 
          self.success = iprot.readBool();
14753 
        else:
14754 
          iprot.skip(ftype)
14755 
      elif fid == 1:
14756 
        if ftype == TType.STRUCT:
14757 
          self.ex = TransactionServiceException()
14758 
          self.ex.read(iprot)
14759 
        else:
14760 
          iprot.skip(ftype)
14761 
      else:
14762 
        iprot.skip(ftype)
14763 
      iprot.readFieldEnd()
14764 
    iprot.readStructEnd()
14765 
 
14766 
  def write(self, oprot):
14767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14769 
      return
14770 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14771 
    if self.success is not None:
14772 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14773 
      oprot.writeBool(self.success)
14774 
      oprot.writeFieldEnd()
14775 
    if self.ex is not None:
14776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14777 
      self.ex.write(oprot)
14778 
      oprot.writeFieldEnd()
14779 
    oprot.writeFieldStop()
14780 
    oprot.writeStructEnd()
14781 
 
14782 
  def validate(self):
14783 
    return
14784 
 
14785 
 
14786 
  def __repr__(self):
14787 
    L = ['%s=%r' % (key, value)
14788 
      for key, value in self.__dict__.iteritems()]
14789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14790 
 
14791 
  def __eq__(self, other):
14792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14793 
 
14794 
  def __ne__(self, other):
14795 
    return not (self == other)
14796 
 
2536 chandransh 14797 
class requestPickupNumber_args:
14798 
  """
14799 
  Attributes:
14800 
   - orderId
4579 rajveer 14801 
   - providerId
2536 chandransh 14802 
  """
14803 
 
14804 
  thrift_spec = (
14805 
    None, # 0
14806 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14807 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14808 
  )
14809 
 
4579 rajveer 14810 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14811 
    self.orderId = orderId
4579 rajveer 14812 
    self.providerId = providerId
2536 chandransh 14813 
 
14814 
  def read(self, iprot):
14815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14817 
      return
14818 
    iprot.readStructBegin()
14819 
    while True:
14820 
      (fname, ftype, fid) = iprot.readFieldBegin()
14821 
      if ftype == TType.STOP:
14822 
        break
14823 
      if fid == 1:
14824 
        if ftype == TType.I64:
14825 
          self.orderId = iprot.readI64();
14826 
        else:
14827 
          iprot.skip(ftype)
4579 rajveer 14828 
      elif fid == 2:
14829 
        if ftype == TType.I64:
14830 
          self.providerId = iprot.readI64();
14831 
        else:
14832 
          iprot.skip(ftype)
2536 chandransh 14833 
      else:
14834 
        iprot.skip(ftype)
14835 
      iprot.readFieldEnd()
14836 
    iprot.readStructEnd()
14837 
 
14838 
  def write(self, oprot):
14839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14841 
      return
14842 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14843 
    if self.orderId is not None:
2536 chandransh 14844 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14845 
      oprot.writeI64(self.orderId)
14846 
      oprot.writeFieldEnd()
4579 rajveer 14847 
    if self.providerId is not None:
14848 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14849 
      oprot.writeI64(self.providerId)
14850 
      oprot.writeFieldEnd()
2536 chandransh 14851 
    oprot.writeFieldStop()
14852 
    oprot.writeStructEnd()
14853 
 
3431 rajveer 14854 
  def validate(self):
14855 
    return
14856 
 
14857 
 
2536 chandransh 14858 
  def __repr__(self):
14859 
    L = ['%s=%r' % (key, value)
14860 
      for key, value in self.__dict__.iteritems()]
14861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14862 
 
14863 
  def __eq__(self, other):
14864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14865 
 
14866 
  def __ne__(self, other):
14867 
    return not (self == other)
14868 
 
14869 
class requestPickupNumber_result:
14870 
  """
14871 
  Attributes:
14872 
   - success
14873 
   - ex
14874 
  """
14875 
 
14876 
  thrift_spec = (
14877 
    (0, TType.BOOL, 'success', None, None, ), # 0
14878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14879 
  )
14880 
 
14881 
  def __init__(self, success=None, ex=None,):
14882 
    self.success = success
14883 
    self.ex = ex
14884 
 
14885 
  def read(self, iprot):
14886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14888 
      return
14889 
    iprot.readStructBegin()
14890 
    while True:
14891 
      (fname, ftype, fid) = iprot.readFieldBegin()
14892 
      if ftype == TType.STOP:
14893 
        break
14894 
      if fid == 0:
14895 
        if ftype == TType.BOOL:
14896 
          self.success = iprot.readBool();
14897 
        else:
14898 
          iprot.skip(ftype)
14899 
      elif fid == 1:
14900 
        if ftype == TType.STRUCT:
14901 
          self.ex = TransactionServiceException()
14902 
          self.ex.read(iprot)
14903 
        else:
14904 
          iprot.skip(ftype)
14905 
      else:
14906 
        iprot.skip(ftype)
14907 
      iprot.readFieldEnd()
14908 
    iprot.readStructEnd()
14909 
 
14910 
  def write(self, oprot):
14911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14913 
      return
14914 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14915 
    if self.success is not None:
2536 chandransh 14916 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14917 
      oprot.writeBool(self.success)
14918 
      oprot.writeFieldEnd()
3431 rajveer 14919 
    if self.ex is not None:
2536 chandransh 14920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14921 
      self.ex.write(oprot)
14922 
      oprot.writeFieldEnd()
14923 
    oprot.writeFieldStop()
14924 
    oprot.writeStructEnd()
14925 
 
3431 rajveer 14926 
  def validate(self):
14927 
    return
14928 
 
14929 
 
2536 chandransh 14930 
  def __repr__(self):
14931 
    L = ['%s=%r' % (key, value)
14932 
      for key, value in self.__dict__.iteritems()]
14933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14934 
 
14935 
  def __eq__(self, other):
14936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14937 
 
14938 
  def __ne__(self, other):
14939 
    return not (self == other)
14940 
 
14941 
class authorizePickup_args:
14942 
  """
14943 
  Attributes:
14944 
   - orderId
14945 
   - pickupNumber
4602 rajveer 14946 
   - providerId
2536 chandransh 14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    None, # 0
14951 
    (1, TType.I64, 'orderId', None, None, ), # 1
14952 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14953 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14954 
  )
14955 
 
4602 rajveer 14956 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14957 
    self.orderId = orderId
14958 
    self.pickupNumber = pickupNumber
4602 rajveer 14959 
    self.providerId = providerId
2536 chandransh 14960 
 
14961 
  def read(self, iprot):
14962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14964 
      return
14965 
    iprot.readStructBegin()
14966 
    while True:
14967 
      (fname, ftype, fid) = iprot.readFieldBegin()
14968 
      if ftype == TType.STOP:
14969 
        break
14970 
      if fid == 1:
14971 
        if ftype == TType.I64:
14972 
          self.orderId = iprot.readI64();
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      elif fid == 2:
14976 
        if ftype == TType.STRING:
14977 
          self.pickupNumber = iprot.readString();
14978 
        else:
14979 
          iprot.skip(ftype)
4602 rajveer 14980 
      elif fid == 3:
14981 
        if ftype == TType.I64:
14982 
          self.providerId = iprot.readI64();
14983 
        else:
14984 
          iprot.skip(ftype)
2536 chandransh 14985 
      else:
14986 
        iprot.skip(ftype)
14987 
      iprot.readFieldEnd()
14988 
    iprot.readStructEnd()
14989 
 
14990 
  def write(self, oprot):
14991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14993 
      return
14994 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14995 
    if self.orderId is not None:
2536 chandransh 14996 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14997 
      oprot.writeI64(self.orderId)
14998 
      oprot.writeFieldEnd()
3431 rajveer 14999 
    if self.pickupNumber is not None:
2536 chandransh 15000 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15001 
      oprot.writeString(self.pickupNumber)
15002 
      oprot.writeFieldEnd()
4602 rajveer 15003 
    if self.providerId is not None:
15004 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15005 
      oprot.writeI64(self.providerId)
15006 
      oprot.writeFieldEnd()
2536 chandransh 15007 
    oprot.writeFieldStop()
15008 
    oprot.writeStructEnd()
15009 
 
3431 rajveer 15010 
  def validate(self):
15011 
    return
15012 
 
15013 
 
2536 chandransh 15014 
  def __repr__(self):
15015 
    L = ['%s=%r' % (key, value)
15016 
      for key, value in self.__dict__.iteritems()]
15017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15018 
 
15019 
  def __eq__(self, other):
15020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15021 
 
15022 
  def __ne__(self, other):
15023 
    return not (self == other)
15024 
 
15025 
class authorizePickup_result:
15026 
  """
15027 
  Attributes:
15028 
   - success
15029 
   - ex
15030 
  """
15031 
 
15032 
  thrift_spec = (
15033 
    (0, TType.BOOL, 'success', None, None, ), # 0
15034 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15035 
  )
15036 
 
15037 
  def __init__(self, success=None, ex=None,):
15038 
    self.success = success
15039 
    self.ex = ex
15040 
 
15041 
  def read(self, iprot):
15042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15044 
      return
15045 
    iprot.readStructBegin()
15046 
    while True:
15047 
      (fname, ftype, fid) = iprot.readFieldBegin()
15048 
      if ftype == TType.STOP:
15049 
        break
15050 
      if fid == 0:
15051 
        if ftype == TType.BOOL:
15052 
          self.success = iprot.readBool();
15053 
        else:
15054 
          iprot.skip(ftype)
15055 
      elif fid == 1:
15056 
        if ftype == TType.STRUCT:
15057 
          self.ex = TransactionServiceException()
15058 
          self.ex.read(iprot)
15059 
        else:
15060 
          iprot.skip(ftype)
15061 
      else:
15062 
        iprot.skip(ftype)
15063 
      iprot.readFieldEnd()
15064 
    iprot.readStructEnd()
15065 
 
15066 
  def write(self, oprot):
15067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15069 
      return
15070 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15071 
    if self.success is not None:
2536 chandransh 15072 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15073 
      oprot.writeBool(self.success)
15074 
      oprot.writeFieldEnd()
3431 rajveer 15075 
    if self.ex is not None:
2536 chandransh 15076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15077 
      self.ex.write(oprot)
15078 
      oprot.writeFieldEnd()
15079 
    oprot.writeFieldStop()
15080 
    oprot.writeStructEnd()
15081 
 
3431 rajveer 15082 
  def validate(self):
15083 
    return
15084 
 
15085 
 
2536 chandransh 15086 
  def __repr__(self):
15087 
    L = ['%s=%r' % (key, value)
15088 
      for key, value in self.__dict__.iteritems()]
15089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15090 
 
15091 
  def __eq__(self, other):
15092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15093 
 
15094 
  def __ne__(self, other):
15095 
    return not (self == other)
15096 
 
2764 chandransh 15097 
class markDoasAsPickedUp_args:
15098 
  """
15099 
  Attributes:
15100 
   - providerId
15101 
   - pickupDetails
15102 
  """
15103 
 
15104 
  thrift_spec = (
15105 
    None, # 0
15106 
    (1, TType.I64, 'providerId', None, None, ), # 1
15107 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15108 
  )
15109 
 
15110 
  def __init__(self, providerId=None, pickupDetails=None,):
15111 
    self.providerId = providerId
15112 
    self.pickupDetails = pickupDetails
15113 
 
15114 
  def read(self, iprot):
15115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15117 
      return
15118 
    iprot.readStructBegin()
15119 
    while True:
15120 
      (fname, ftype, fid) = iprot.readFieldBegin()
15121 
      if ftype == TType.STOP:
15122 
        break
15123 
      if fid == 1:
15124 
        if ftype == TType.I64:
15125 
          self.providerId = iprot.readI64();
15126 
        else:
15127 
          iprot.skip(ftype)
15128 
      elif fid == 2:
15129 
        if ftype == TType.MAP:
15130 
          self.pickupDetails = {}
5386 phani.kuma 15131 
          (_ktype337, _vtype338, _size336 ) = iprot.readMapBegin()
15132 
          for _i340 in xrange(_size336):
15133 
            _key341 = iprot.readString();
15134 
            _val342 = iprot.readString();
15135 
            self.pickupDetails[_key341] = _val342
2764 chandransh 15136 
          iprot.readMapEnd()
15137 
        else:
15138 
          iprot.skip(ftype)
15139 
      else:
15140 
        iprot.skip(ftype)
15141 
      iprot.readFieldEnd()
15142 
    iprot.readStructEnd()
15143 
 
15144 
  def write(self, oprot):
15145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15147 
      return
15148 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15149 
    if self.providerId is not None:
2764 chandransh 15150 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15151 
      oprot.writeI64(self.providerId)
15152 
      oprot.writeFieldEnd()
3431 rajveer 15153 
    if self.pickupDetails is not None:
2764 chandransh 15154 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15155 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5386 phani.kuma 15156 
      for kiter343,viter344 in self.pickupDetails.items():
15157 
        oprot.writeString(kiter343)
15158 
        oprot.writeString(viter344)
2764 chandransh 15159 
      oprot.writeMapEnd()
15160 
      oprot.writeFieldEnd()
15161 
    oprot.writeFieldStop()
15162 
    oprot.writeStructEnd()
15163 
 
3431 rajveer 15164 
  def validate(self):
15165 
    return
15166 
 
15167 
 
2764 chandransh 15168 
  def __repr__(self):
15169 
    L = ['%s=%r' % (key, value)
15170 
      for key, value in self.__dict__.iteritems()]
15171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15172 
 
15173 
  def __eq__(self, other):
15174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15175 
 
15176 
  def __ne__(self, other):
15177 
    return not (self == other)
15178 
 
15179 
class markDoasAsPickedUp_result:
4910 phani.kuma 15180 
 
15181 
  thrift_spec = (
15182 
  )
15183 
 
15184 
  def read(self, iprot):
15185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15187 
      return
15188 
    iprot.readStructBegin()
15189 
    while True:
15190 
      (fname, ftype, fid) = iprot.readFieldBegin()
15191 
      if ftype == TType.STOP:
15192 
        break
15193 
      else:
15194 
        iprot.skip(ftype)
15195 
      iprot.readFieldEnd()
15196 
    iprot.readStructEnd()
15197 
 
15198 
  def write(self, oprot):
15199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15201 
      return
15202 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
15221 
class getDoasNotPickedUp_args:
2764 chandransh 15222 
  """
15223 
  Attributes:
4910 phani.kuma 15224 
   - providerId
15225 
  """
15226 
 
15227 
  thrift_spec = (
15228 
    None, # 0
15229 
    (1, TType.I64, 'providerId', None, None, ), # 1
15230 
  )
15231 
 
15232 
  def __init__(self, providerId=None,):
15233 
    self.providerId = providerId
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.providerId = iprot.readI64();
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15259 
    if self.providerId is not None:
15260 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15261 
      oprot.writeI64(self.providerId)
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class getDoasNotPickedUp_result:
15282 
  """
15283 
  Attributes:
2764 chandransh 15284 
   - success
15285 
  """
15286 
 
15287 
  thrift_spec = (
15288 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15289 
  )
15290 
 
15291 
  def __init__(self, success=None,):
15292 
    self.success = success
15293 
 
15294 
  def read(self, iprot):
15295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15297 
      return
15298 
    iprot.readStructBegin()
15299 
    while True:
15300 
      (fname, ftype, fid) = iprot.readFieldBegin()
15301 
      if ftype == TType.STOP:
15302 
        break
15303 
      if fid == 0:
15304 
        if ftype == TType.LIST:
15305 
          self.success = []
5386 phani.kuma 15306 
          (_etype348, _size345) = iprot.readListBegin()
15307 
          for _i349 in xrange(_size345):
15308 
            _elem350 = Order()
15309 
            _elem350.read(iprot)
15310 
            self.success.append(_elem350)
2764 chandransh 15311 
          iprot.readListEnd()
15312 
        else:
15313 
          iprot.skip(ftype)
15314 
      else:
15315 
        iprot.skip(ftype)
15316 
      iprot.readFieldEnd()
15317 
    iprot.readStructEnd()
15318 
 
15319 
  def write(self, oprot):
15320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15322 
      return
4910 phani.kuma 15323 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15324 
    if self.success is not None:
2764 chandransh 15325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 15327 
      for iter351 in self.success:
15328 
        iter351.write(oprot)
2764 chandransh 15329 
      oprot.writeListEnd()
15330 
      oprot.writeFieldEnd()
15331 
    oprot.writeFieldStop()
15332 
    oprot.writeStructEnd()
15333 
 
3431 rajveer 15334 
  def validate(self):
15335 
    return
15336 
 
15337 
 
2764 chandransh 15338 
  def __repr__(self):
15339 
    L = ['%s=%r' % (key, value)
15340 
      for key, value in self.__dict__.iteritems()]
15341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15342 
 
15343 
  def __eq__(self, other):
15344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15345 
 
15346 
  def __ne__(self, other):
15347 
    return not (self == other)
15348 
 
4741 phani.kuma 15349 
class markReturnOrdersAsPickedUp_args:
15350 
  """
15351 
  Attributes:
15352 
   - providerId
15353 
   - pickupDetails
15354 
  """
15355 
 
15356 
  thrift_spec = (
15357 
    None, # 0
15358 
    (1, TType.I64, 'providerId', None, None, ), # 1
15359 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15360 
  )
15361 
 
15362 
  def __init__(self, providerId=None, pickupDetails=None,):
15363 
    self.providerId = providerId
15364 
    self.pickupDetails = pickupDetails
15365 
 
15366 
  def read(self, iprot):
15367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15369 
      return
15370 
    iprot.readStructBegin()
15371 
    while True:
15372 
      (fname, ftype, fid) = iprot.readFieldBegin()
15373 
      if ftype == TType.STOP:
15374 
        break
15375 
      if fid == 1:
15376 
        if ftype == TType.I64:
15377 
          self.providerId = iprot.readI64();
15378 
        else:
15379 
          iprot.skip(ftype)
15380 
      elif fid == 2:
15381 
        if ftype == TType.MAP:
15382 
          self.pickupDetails = {}
5386 phani.kuma 15383 
          (_ktype353, _vtype354, _size352 ) = iprot.readMapBegin()
15384 
          for _i356 in xrange(_size352):
15385 
            _key357 = iprot.readString();
15386 
            _val358 = iprot.readString();
15387 
            self.pickupDetails[_key357] = _val358
4741 phani.kuma 15388 
          iprot.readMapEnd()
15389 
        else:
15390 
          iprot.skip(ftype)
15391 
      else:
15392 
        iprot.skip(ftype)
15393 
      iprot.readFieldEnd()
15394 
    iprot.readStructEnd()
15395 
 
15396 
  def write(self, oprot):
15397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15399 
      return
15400 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15401 
    if self.providerId is not None:
15402 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15403 
      oprot.writeI64(self.providerId)
15404 
      oprot.writeFieldEnd()
15405 
    if self.pickupDetails is not None:
15406 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15407 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5386 phani.kuma 15408 
      for kiter359,viter360 in self.pickupDetails.items():
15409 
        oprot.writeString(kiter359)
15410 
        oprot.writeString(viter360)
4741 phani.kuma 15411 
      oprot.writeMapEnd()
15412 
      oprot.writeFieldEnd()
15413 
    oprot.writeFieldStop()
15414 
    oprot.writeStructEnd()
15415 
 
15416 
  def validate(self):
15417 
    return
15418 
 
15419 
 
15420 
  def __repr__(self):
15421 
    L = ['%s=%r' % (key, value)
15422 
      for key, value in self.__dict__.iteritems()]
15423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15424 
 
15425 
  def __eq__(self, other):
15426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15427 
 
15428 
  def __ne__(self, other):
15429 
    return not (self == other)
15430 
 
15431 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15432 
 
15433 
  thrift_spec = (
15434 
  )
15435 
 
15436 
  def read(self, iprot):
15437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15439 
      return
15440 
    iprot.readStructBegin()
15441 
    while True:
15442 
      (fname, ftype, fid) = iprot.readFieldBegin()
15443 
      if ftype == TType.STOP:
15444 
        break
15445 
      else:
15446 
        iprot.skip(ftype)
15447 
      iprot.readFieldEnd()
15448 
    iprot.readStructEnd()
15449 
 
15450 
  def write(self, oprot):
15451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15453 
      return
15454 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15455 
    oprot.writeFieldStop()
15456 
    oprot.writeStructEnd()
15457 
 
15458 
  def validate(self):
15459 
    return
15460 
 
15461 
 
15462 
  def __repr__(self):
15463 
    L = ['%s=%r' % (key, value)
15464 
      for key, value in self.__dict__.iteritems()]
15465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15466 
 
15467 
  def __eq__(self, other):
15468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15469 
 
15470 
  def __ne__(self, other):
15471 
    return not (self == other)
15472 
 
15473 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15474 
  """
15475 
  Attributes:
4910 phani.kuma 15476 
   - providerId
15477 
  """
15478 
 
15479 
  thrift_spec = (
15480 
    None, # 0
15481 
    (1, TType.I64, 'providerId', None, None, ), # 1
15482 
  )
15483 
 
15484 
  def __init__(self, providerId=None,):
15485 
    self.providerId = providerId
15486 
 
15487 
  def read(self, iprot):
15488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15490 
      return
15491 
    iprot.readStructBegin()
15492 
    while True:
15493 
      (fname, ftype, fid) = iprot.readFieldBegin()
15494 
      if ftype == TType.STOP:
15495 
        break
15496 
      if fid == 1:
15497 
        if ftype == TType.I64:
15498 
          self.providerId = iprot.readI64();
15499 
        else:
15500 
          iprot.skip(ftype)
15501 
      else:
15502 
        iprot.skip(ftype)
15503 
      iprot.readFieldEnd()
15504 
    iprot.readStructEnd()
15505 
 
15506 
  def write(self, oprot):
15507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15509 
      return
15510 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15511 
    if self.providerId is not None:
15512 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15513 
      oprot.writeI64(self.providerId)
15514 
      oprot.writeFieldEnd()
15515 
    oprot.writeFieldStop()
15516 
    oprot.writeStructEnd()
15517 
 
15518 
  def validate(self):
15519 
    return
15520 
 
15521 
 
15522 
  def __repr__(self):
15523 
    L = ['%s=%r' % (key, value)
15524 
      for key, value in self.__dict__.iteritems()]
15525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15526 
 
15527 
  def __eq__(self, other):
15528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15529 
 
15530 
  def __ne__(self, other):
15531 
    return not (self == other)
15532 
 
15533 
class getReturnOrdersNotPickedUp_result:
15534 
  """
15535 
  Attributes:
4741 phani.kuma 15536 
   - success
15537 
  """
15538 
 
15539 
  thrift_spec = (
15540 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15541 
  )
15542 
 
15543 
  def __init__(self, success=None,):
15544 
    self.success = success
15545 
 
15546 
  def read(self, iprot):
15547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15549 
      return
15550 
    iprot.readStructBegin()
15551 
    while True:
15552 
      (fname, ftype, fid) = iprot.readFieldBegin()
15553 
      if ftype == TType.STOP:
15554 
        break
15555 
      if fid == 0:
15556 
        if ftype == TType.LIST:
15557 
          self.success = []
5386 phani.kuma 15558 
          (_etype364, _size361) = iprot.readListBegin()
15559 
          for _i365 in xrange(_size361):
15560 
            _elem366 = Order()
15561 
            _elem366.read(iprot)
15562 
            self.success.append(_elem366)
4741 phani.kuma 15563 
          iprot.readListEnd()
15564 
        else:
15565 
          iprot.skip(ftype)
15566 
      else:
15567 
        iprot.skip(ftype)
15568 
      iprot.readFieldEnd()
15569 
    iprot.readStructEnd()
15570 
 
15571 
  def write(self, oprot):
15572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15574 
      return
4910 phani.kuma 15575 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15576 
    if self.success is not None:
15577 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15578 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 15579 
      for iter367 in self.success:
15580 
        iter367.write(oprot)
4741 phani.kuma 15581 
      oprot.writeListEnd()
15582 
      oprot.writeFieldEnd()
15583 
    oprot.writeFieldStop()
15584 
    oprot.writeStructEnd()
15585 
 
15586 
  def validate(self):
15587 
    return
15588 
 
15589 
 
15590 
  def __repr__(self):
15591 
    L = ['%s=%r' % (key, value)
15592 
      for key, value in self.__dict__.iteritems()]
15593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15594 
 
15595 
  def __eq__(self, other):
15596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15597 
 
15598 
  def __ne__(self, other):
15599 
    return not (self == other)
15600 
 
2616 chandransh 15601 
class receiveReturn_args:
2591 chandransh 15602 
  """
15603 
  Attributes:
15604 
   - orderId
4479 rajveer 15605 
   - receiveCondition
2591 chandransh 15606 
  """
2536 chandransh 15607 
 
2591 chandransh 15608 
  thrift_spec = (
15609 
    None, # 0
15610 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15611 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15612 
  )
15613 
 
4479 rajveer 15614 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15615 
    self.orderId = orderId
4479 rajveer 15616 
    self.receiveCondition = receiveCondition
2591 chandransh 15617 
 
15618 
  def read(self, iprot):
15619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15621 
      return
15622 
    iprot.readStructBegin()
15623 
    while True:
15624 
      (fname, ftype, fid) = iprot.readFieldBegin()
15625 
      if ftype == TType.STOP:
15626 
        break
15627 
      if fid == 1:
15628 
        if ftype == TType.I64:
15629 
          self.orderId = iprot.readI64();
15630 
        else:
15631 
          iprot.skip(ftype)
4479 rajveer 15632 
      elif fid == 2:
15633 
        if ftype == TType.I64:
15634 
          self.receiveCondition = iprot.readI64();
15635 
        else:
15636 
          iprot.skip(ftype)
2591 chandransh 15637 
      else:
15638 
        iprot.skip(ftype)
15639 
      iprot.readFieldEnd()
15640 
    iprot.readStructEnd()
15641 
 
15642 
  def write(self, oprot):
15643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15645 
      return
2616 chandransh 15646 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15647 
    if self.orderId is not None:
2591 chandransh 15648 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15649 
      oprot.writeI64(self.orderId)
15650 
      oprot.writeFieldEnd()
4479 rajveer 15651 
    if self.receiveCondition is not None:
15652 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15653 
      oprot.writeI64(self.receiveCondition)
15654 
      oprot.writeFieldEnd()
2591 chandransh 15655 
    oprot.writeFieldStop()
15656 
    oprot.writeStructEnd()
15657 
 
3431 rajveer 15658 
  def validate(self):
15659 
    return
15660 
 
15661 
 
2591 chandransh 15662 
  def __repr__(self):
15663 
    L = ['%s=%r' % (key, value)
15664 
      for key, value in self.__dict__.iteritems()]
15665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15666 
 
15667 
  def __eq__(self, other):
15668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15669 
 
15670 
  def __ne__(self, other):
15671 
    return not (self == other)
15672 
 
2616 chandransh 15673 
class receiveReturn_result:
2591 chandransh 15674 
  """
15675 
  Attributes:
15676 
   - success
15677 
   - ex
15678 
  """
15679 
 
15680 
  thrift_spec = (
15681 
    (0, TType.BOOL, 'success', None, None, ), # 0
15682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15683 
  )
15684 
 
15685 
  def __init__(self, success=None, ex=None,):
15686 
    self.success = success
15687 
    self.ex = ex
15688 
 
15689 
  def read(self, iprot):
15690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15692 
      return
15693 
    iprot.readStructBegin()
15694 
    while True:
15695 
      (fname, ftype, fid) = iprot.readFieldBegin()
15696 
      if ftype == TType.STOP:
15697 
        break
15698 
      if fid == 0:
15699 
        if ftype == TType.BOOL:
15700 
          self.success = iprot.readBool();
15701 
        else:
15702 
          iprot.skip(ftype)
15703 
      elif fid == 1:
15704 
        if ftype == TType.STRUCT:
15705 
          self.ex = TransactionServiceException()
15706 
          self.ex.read(iprot)
15707 
        else:
15708 
          iprot.skip(ftype)
15709 
      else:
15710 
        iprot.skip(ftype)
15711 
      iprot.readFieldEnd()
15712 
    iprot.readStructEnd()
15713 
 
15714 
  def write(self, oprot):
15715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15717 
      return
2616 chandransh 15718 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15719 
    if self.success is not None:
2591 chandransh 15720 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15721 
      oprot.writeBool(self.success)
15722 
      oprot.writeFieldEnd()
3431 rajveer 15723 
    if self.ex is not None:
2591 chandransh 15724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15725 
      self.ex.write(oprot)
15726 
      oprot.writeFieldEnd()
15727 
    oprot.writeFieldStop()
15728 
    oprot.writeStructEnd()
15729 
 
3431 rajveer 15730 
  def validate(self):
15731 
    return
15732 
 
15733 
 
2591 chandransh 15734 
  def __repr__(self):
15735 
    L = ['%s=%r' % (key, value)
15736 
      for key, value in self.__dict__.iteritems()]
15737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15738 
 
15739 
  def __eq__(self, other):
15740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15741 
 
15742 
  def __ne__(self, other):
15743 
    return not (self == other)
15744 
 
15745 
class validateDoa_args:
15746 
  """
15747 
  Attributes:
15748 
   - orderId
15749 
   - isValid
15750 
  """
15751 
 
15752 
  thrift_spec = (
15753 
    None, # 0
15754 
    (1, TType.I64, 'orderId', None, None, ), # 1
15755 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15756 
  )
15757 
 
15758 
  def __init__(self, orderId=None, isValid=None,):
15759 
    self.orderId = orderId
15760 
    self.isValid = isValid
15761 
 
15762 
  def read(self, iprot):
15763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15765 
      return
15766 
    iprot.readStructBegin()
15767 
    while True:
15768 
      (fname, ftype, fid) = iprot.readFieldBegin()
15769 
      if ftype == TType.STOP:
15770 
        break
15771 
      if fid == 1:
15772 
        if ftype == TType.I64:
15773 
          self.orderId = iprot.readI64();
15774 
        else:
15775 
          iprot.skip(ftype)
15776 
      elif fid == 2:
15777 
        if ftype == TType.BOOL:
15778 
          self.isValid = iprot.readBool();
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      else:
15782 
        iprot.skip(ftype)
15783 
      iprot.readFieldEnd()
15784 
    iprot.readStructEnd()
15785 
 
15786 
  def write(self, oprot):
15787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15789 
      return
15790 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15791 
    if self.orderId is not None:
2591 chandransh 15792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15793 
      oprot.writeI64(self.orderId)
15794 
      oprot.writeFieldEnd()
3431 rajveer 15795 
    if self.isValid is not None:
2591 chandransh 15796 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15797 
      oprot.writeBool(self.isValid)
15798 
      oprot.writeFieldEnd()
15799 
    oprot.writeFieldStop()
15800 
    oprot.writeStructEnd()
15801 
 
3431 rajveer 15802 
  def validate(self):
15803 
    return
15804 
 
15805 
 
2591 chandransh 15806 
  def __repr__(self):
15807 
    L = ['%s=%r' % (key, value)
15808 
      for key, value in self.__dict__.iteritems()]
15809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15810 
 
15811 
  def __eq__(self, other):
15812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15813 
 
15814 
  def __ne__(self, other):
15815 
    return not (self == other)
15816 
 
15817 
class validateDoa_result:
15818 
  """
15819 
  Attributes:
15820 
   - success
15821 
   - ex
15822 
  """
15823 
 
15824 
  thrift_spec = (
15825 
    (0, TType.BOOL, 'success', None, None, ), # 0
15826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15827 
  )
15828 
 
15829 
  def __init__(self, success=None, ex=None,):
15830 
    self.success = success
15831 
    self.ex = ex
15832 
 
15833 
  def read(self, iprot):
15834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15836 
      return
15837 
    iprot.readStructBegin()
15838 
    while True:
15839 
      (fname, ftype, fid) = iprot.readFieldBegin()
15840 
      if ftype == TType.STOP:
15841 
        break
15842 
      if fid == 0:
15843 
        if ftype == TType.BOOL:
15844 
          self.success = iprot.readBool();
15845 
        else:
15846 
          iprot.skip(ftype)
15847 
      elif fid == 1:
15848 
        if ftype == TType.STRUCT:
15849 
          self.ex = TransactionServiceException()
15850 
          self.ex.read(iprot)
15851 
        else:
15852 
          iprot.skip(ftype)
15853 
      else:
15854 
        iprot.skip(ftype)
15855 
      iprot.readFieldEnd()
15856 
    iprot.readStructEnd()
15857 
 
15858 
  def write(self, oprot):
15859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15861 
      return
15862 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15863 
    if self.success is not None:
2591 chandransh 15864 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15865 
      oprot.writeBool(self.success)
15866 
      oprot.writeFieldEnd()
3431 rajveer 15867 
    if self.ex is not None:
2591 chandransh 15868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15869 
      self.ex.write(oprot)
15870 
      oprot.writeFieldEnd()
15871 
    oprot.writeFieldStop()
15872 
    oprot.writeStructEnd()
15873 
 
3431 rajveer 15874 
  def validate(self):
15875 
    return
15876 
 
15877 
 
2591 chandransh 15878 
  def __repr__(self):
15879 
    L = ['%s=%r' % (key, value)
15880 
      for key, value in self.__dict__.iteritems()]
15881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15882 
 
15883 
  def __eq__(self, other):
15884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15885 
 
15886 
  def __ne__(self, other):
15887 
    return not (self == other)
15888 
 
4495 rajveer 15889 
class validateReturnProduct_args:
15890 
  """
15891 
  Attributes:
15892 
   - orderId
15893 
   - isUsable
15894 
  """
15895 
 
15896 
  thrift_spec = (
15897 
    None, # 0
15898 
    (1, TType.I64, 'orderId', None, None, ), # 1
15899 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15900 
  )
15901 
 
15902 
  def __init__(self, orderId=None, isUsable=None,):
15903 
    self.orderId = orderId
15904 
    self.isUsable = isUsable
15905 
 
15906 
  def read(self, iprot):
15907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15909 
      return
15910 
    iprot.readStructBegin()
15911 
    while True:
15912 
      (fname, ftype, fid) = iprot.readFieldBegin()
15913 
      if ftype == TType.STOP:
15914 
        break
15915 
      if fid == 1:
15916 
        if ftype == TType.I64:
15917 
          self.orderId = iprot.readI64();
15918 
        else:
15919 
          iprot.skip(ftype)
15920 
      elif fid == 2:
15921 
        if ftype == TType.BOOL:
15922 
          self.isUsable = iprot.readBool();
15923 
        else:
15924 
          iprot.skip(ftype)
15925 
      else:
15926 
        iprot.skip(ftype)
15927 
      iprot.readFieldEnd()
15928 
    iprot.readStructEnd()
15929 
 
15930 
  def write(self, oprot):
15931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15933 
      return
15934 
    oprot.writeStructBegin('validateReturnProduct_args')
15935 
    if self.orderId is not None:
15936 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15937 
      oprot.writeI64(self.orderId)
15938 
      oprot.writeFieldEnd()
15939 
    if self.isUsable is not None:
15940 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15941 
      oprot.writeBool(self.isUsable)
15942 
      oprot.writeFieldEnd()
15943 
    oprot.writeFieldStop()
15944 
    oprot.writeStructEnd()
15945 
 
15946 
  def validate(self):
15947 
    return
15948 
 
15949 
 
15950 
  def __repr__(self):
15951 
    L = ['%s=%r' % (key, value)
15952 
      for key, value in self.__dict__.iteritems()]
15953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15954 
 
15955 
  def __eq__(self, other):
15956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15957 
 
15958 
  def __ne__(self, other):
15959 
    return not (self == other)
15960 
 
15961 
class validateReturnProduct_result:
15962 
  """
15963 
  Attributes:
15964 
   - success
15965 
   - ex
15966 
  """
15967 
 
15968 
  thrift_spec = (
15969 
    (0, TType.BOOL, 'success', None, None, ), # 0
15970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15971 
  )
15972 
 
15973 
  def __init__(self, success=None, ex=None,):
15974 
    self.success = success
15975 
    self.ex = ex
15976 
 
15977 
  def read(self, iprot):
15978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15980 
      return
15981 
    iprot.readStructBegin()
15982 
    while True:
15983 
      (fname, ftype, fid) = iprot.readFieldBegin()
15984 
      if ftype == TType.STOP:
15985 
        break
15986 
      if fid == 0:
15987 
        if ftype == TType.BOOL:
15988 
          self.success = iprot.readBool();
15989 
        else:
15990 
          iprot.skip(ftype)
15991 
      elif fid == 1:
15992 
        if ftype == TType.STRUCT:
15993 
          self.ex = TransactionServiceException()
15994 
          self.ex.read(iprot)
15995 
        else:
15996 
          iprot.skip(ftype)
15997 
      else:
15998 
        iprot.skip(ftype)
15999 
      iprot.readFieldEnd()
16000 
    iprot.readStructEnd()
16001 
 
16002 
  def write(self, oprot):
16003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16005 
      return
16006 
    oprot.writeStructBegin('validateReturnProduct_result')
16007 
    if self.success is not None:
16008 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16009 
      oprot.writeBool(self.success)
16010 
      oprot.writeFieldEnd()
16011 
    if self.ex is not None:
16012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16013 
      self.ex.write(oprot)
16014 
      oprot.writeFieldEnd()
16015 
    oprot.writeFieldStop()
16016 
    oprot.writeStructEnd()
16017 
 
16018 
  def validate(self):
16019 
    return
16020 
 
16021 
 
16022 
  def __repr__(self):
16023 
    L = ['%s=%r' % (key, value)
16024 
      for key, value in self.__dict__.iteritems()]
16025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16026 
 
16027 
  def __eq__(self, other):
16028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16029 
 
16030 
  def __ne__(self, other):
16031 
    return not (self == other)
16032 
 
2616 chandransh 16033 
class reshipOrder_args:
16034 
  """
16035 
  Attributes:
16036 
   - orderId
16037 
  """
2591 chandransh 16038 
 
2616 chandransh 16039 
  thrift_spec = (
16040 
    None, # 0
16041 
    (1, TType.I64, 'orderId', None, None, ), # 1
16042 
  )
16043 
 
16044 
  def __init__(self, orderId=None,):
16045 
    self.orderId = orderId
16046 
 
16047 
  def read(self, iprot):
16048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16050 
      return
16051 
    iprot.readStructBegin()
16052 
    while True:
16053 
      (fname, ftype, fid) = iprot.readFieldBegin()
16054 
      if ftype == TType.STOP:
16055 
        break
16056 
      if fid == 1:
16057 
        if ftype == TType.I64:
16058 
          self.orderId = iprot.readI64();
16059 
        else:
16060 
          iprot.skip(ftype)
16061 
      else:
16062 
        iprot.skip(ftype)
16063 
      iprot.readFieldEnd()
16064 
    iprot.readStructEnd()
16065 
 
16066 
  def write(self, oprot):
16067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16069 
      return
16070 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16071 
    if self.orderId is not None:
2616 chandransh 16072 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16073 
      oprot.writeI64(self.orderId)
16074 
      oprot.writeFieldEnd()
16075 
    oprot.writeFieldStop()
16076 
    oprot.writeStructEnd()
16077 
 
3431 rajveer 16078 
  def validate(self):
16079 
    return
16080 
 
16081 
 
2616 chandransh 16082 
  def __repr__(self):
16083 
    L = ['%s=%r' % (key, value)
16084 
      for key, value in self.__dict__.iteritems()]
16085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16086 
 
16087 
  def __eq__(self, other):
16088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16089 
 
16090 
  def __ne__(self, other):
16091 
    return not (self == other)
16092 
 
16093 
class reshipOrder_result:
16094 
  """
16095 
  Attributes:
16096 
   - success
16097 
   - ex
16098 
  """
16099 
 
16100 
  thrift_spec = (
16101 
    (0, TType.I64, 'success', None, None, ), # 0
16102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16103 
  )
16104 
 
16105 
  def __init__(self, success=None, ex=None,):
16106 
    self.success = success
16107 
    self.ex = ex
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      if fid == 0:
16119 
        if ftype == TType.I64:
16120 
          self.success = iprot.readI64();
16121 
        else:
16122 
          iprot.skip(ftype)
16123 
      elif fid == 1:
16124 
        if ftype == TType.STRUCT:
16125 
          self.ex = TransactionServiceException()
16126 
          self.ex.read(iprot)
16127 
        else:
16128 
          iprot.skip(ftype)
16129 
      else:
16130 
        iprot.skip(ftype)
16131 
      iprot.readFieldEnd()
16132 
    iprot.readStructEnd()
16133 
 
16134 
  def write(self, oprot):
16135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16137 
      return
16138 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16139 
    if self.success is not None:
2616 chandransh 16140 
      oprot.writeFieldBegin('success', TType.I64, 0)
16141 
      oprot.writeI64(self.success)
16142 
      oprot.writeFieldEnd()
3431 rajveer 16143 
    if self.ex is not None:
2616 chandransh 16144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16145 
      self.ex.write(oprot)
16146 
      oprot.writeFieldEnd()
16147 
    oprot.writeFieldStop()
16148 
    oprot.writeStructEnd()
16149 
 
3431 rajveer 16150 
  def validate(self):
16151 
    return
16152 
 
16153 
 
2616 chandransh 16154 
  def __repr__(self):
16155 
    L = ['%s=%r' % (key, value)
16156 
      for key, value in self.__dict__.iteritems()]
16157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16158 
 
16159 
  def __eq__(self, other):
16160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16161 
 
16162 
  def __ne__(self, other):
16163 
    return not (self == other)
16164 
 
16165 
class refundOrder_args:
16166 
  """
16167 
  Attributes:
16168 
   - orderId
3226 chandransh 16169 
   - refundedBy
16170 
   - reason
2616 chandransh 16171 
  """
16172 
 
16173 
  thrift_spec = (
16174 
    None, # 0
16175 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16176 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16177 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16178 
  )
16179 
 
3226 chandransh 16180 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16181 
    self.orderId = orderId
3226 chandransh 16182 
    self.refundedBy = refundedBy
16183 
    self.reason = reason
2616 chandransh 16184 
 
16185 
  def read(self, iprot):
16186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16188 
      return
16189 
    iprot.readStructBegin()
16190 
    while True:
16191 
      (fname, ftype, fid) = iprot.readFieldBegin()
16192 
      if ftype == TType.STOP:
16193 
        break
16194 
      if fid == 1:
16195 
        if ftype == TType.I64:
16196 
          self.orderId = iprot.readI64();
16197 
        else:
16198 
          iprot.skip(ftype)
3226 chandransh 16199 
      elif fid == 2:
16200 
        if ftype == TType.STRING:
16201 
          self.refundedBy = iprot.readString();
16202 
        else:
16203 
          iprot.skip(ftype)
16204 
      elif fid == 3:
16205 
        if ftype == TType.STRING:
16206 
          self.reason = iprot.readString();
16207 
        else:
16208 
          iprot.skip(ftype)
2616 chandransh 16209 
      else:
16210 
        iprot.skip(ftype)
16211 
      iprot.readFieldEnd()
16212 
    iprot.readStructEnd()
16213 
 
16214 
  def write(self, oprot):
16215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16217 
      return
16218 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16219 
    if self.orderId is not None:
2616 chandransh 16220 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16221 
      oprot.writeI64(self.orderId)
16222 
      oprot.writeFieldEnd()
3431 rajveer 16223 
    if self.refundedBy is not None:
3226 chandransh 16224 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16225 
      oprot.writeString(self.refundedBy)
16226 
      oprot.writeFieldEnd()
3431 rajveer 16227 
    if self.reason is not None:
3226 chandransh 16228 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16229 
      oprot.writeString(self.reason)
16230 
      oprot.writeFieldEnd()
2616 chandransh 16231 
    oprot.writeFieldStop()
16232 
    oprot.writeStructEnd()
16233 
 
3431 rajveer 16234 
  def validate(self):
16235 
    return
16236 
 
16237 
 
2616 chandransh 16238 
  def __repr__(self):
16239 
    L = ['%s=%r' % (key, value)
16240 
      for key, value in self.__dict__.iteritems()]
16241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16242 
 
16243 
  def __eq__(self, other):
16244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16245 
 
16246 
  def __ne__(self, other):
16247 
    return not (self == other)
16248 
 
16249 
class refundOrder_result:
16250 
  """
16251 
  Attributes:
16252 
   - success
16253 
   - ex
16254 
  """
16255 
 
16256 
  thrift_spec = (
16257 
    (0, TType.BOOL, 'success', None, None, ), # 0
16258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16259 
  )
16260 
 
16261 
  def __init__(self, success=None, ex=None,):
16262 
    self.success = success
16263 
    self.ex = ex
16264 
 
16265 
  def read(self, iprot):
16266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16268 
      return
16269 
    iprot.readStructBegin()
16270 
    while True:
16271 
      (fname, ftype, fid) = iprot.readFieldBegin()
16272 
      if ftype == TType.STOP:
16273 
        break
16274 
      if fid == 0:
16275 
        if ftype == TType.BOOL:
16276 
          self.success = iprot.readBool();
16277 
        else:
16278 
          iprot.skip(ftype)
16279 
      elif fid == 1:
16280 
        if ftype == TType.STRUCT:
16281 
          self.ex = TransactionServiceException()
16282 
          self.ex.read(iprot)
16283 
        else:
16284 
          iprot.skip(ftype)
16285 
      else:
16286 
        iprot.skip(ftype)
16287 
      iprot.readFieldEnd()
16288 
    iprot.readStructEnd()
16289 
 
16290 
  def write(self, oprot):
16291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16293 
      return
16294 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16295 
    if self.success is not None:
2616 chandransh 16296 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16297 
      oprot.writeBool(self.success)
16298 
      oprot.writeFieldEnd()
3431 rajveer 16299 
    if self.ex is not None:
2616 chandransh 16300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16301 
      self.ex.write(oprot)
16302 
      oprot.writeFieldEnd()
16303 
    oprot.writeFieldStop()
16304 
    oprot.writeStructEnd()
16305 
 
3431 rajveer 16306 
  def validate(self):
16307 
    return
16308 
 
16309 
 
2616 chandransh 16310 
  def __repr__(self):
16311 
    L = ['%s=%r' % (key, value)
16312 
      for key, value in self.__dict__.iteritems()]
16313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16314 
 
16315 
  def __eq__(self, other):
16316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16317 
 
16318 
  def __ne__(self, other):
16319 
    return not (self == other)
16320 
 
2690 chandransh 16321 
class getReturnOrders_args:
16322 
  """
16323 
  Attributes:
16324 
   - warehouseId
16325 
   - fromDate
16326 
   - toDate
16327 
  """
2616 chandransh 16328 
 
2690 chandransh 16329 
  thrift_spec = (
16330 
    None, # 0
16331 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16332 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16333 
    (3, TType.I64, 'toDate', None, None, ), # 3
16334 
  )
16335 
 
16336 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16337 
    self.warehouseId = warehouseId
16338 
    self.fromDate = fromDate
16339 
    self.toDate = toDate
16340 
 
16341 
  def read(self, iprot):
16342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16344 
      return
16345 
    iprot.readStructBegin()
16346 
    while True:
16347 
      (fname, ftype, fid) = iprot.readFieldBegin()
16348 
      if ftype == TType.STOP:
16349 
        break
16350 
      if fid == 1:
16351 
        if ftype == TType.I64:
16352 
          self.warehouseId = iprot.readI64();
16353 
        else:
16354 
          iprot.skip(ftype)
16355 
      elif fid == 2:
16356 
        if ftype == TType.I64:
16357 
          self.fromDate = iprot.readI64();
16358 
        else:
16359 
          iprot.skip(ftype)
16360 
      elif fid == 3:
16361 
        if ftype == TType.I64:
16362 
          self.toDate = iprot.readI64();
16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      else:
16366 
        iprot.skip(ftype)
16367 
      iprot.readFieldEnd()
16368 
    iprot.readStructEnd()
16369 
 
16370 
  def write(self, oprot):
16371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16373 
      return
16374 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16375 
    if self.warehouseId is not None:
2690 chandransh 16376 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16377 
      oprot.writeI64(self.warehouseId)
16378 
      oprot.writeFieldEnd()
3431 rajveer 16379 
    if self.fromDate is not None:
2690 chandransh 16380 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16381 
      oprot.writeI64(self.fromDate)
16382 
      oprot.writeFieldEnd()
3431 rajveer 16383 
    if self.toDate is not None:
2690 chandransh 16384 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16385 
      oprot.writeI64(self.toDate)
16386 
      oprot.writeFieldEnd()
16387 
    oprot.writeFieldStop()
16388 
    oprot.writeStructEnd()
16389 
 
3431 rajveer 16390 
  def validate(self):
16391 
    return
16392 
 
16393 
 
2690 chandransh 16394 
  def __repr__(self):
16395 
    L = ['%s=%r' % (key, value)
16396 
      for key, value in self.__dict__.iteritems()]
16397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16398 
 
16399 
  def __eq__(self, other):
16400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16401 
 
16402 
  def __ne__(self, other):
16403 
    return not (self == other)
16404 
 
16405 
class getReturnOrders_result:
16406 
  """
16407 
  Attributes:
16408 
   - success
16409 
  """
16410 
 
16411 
  thrift_spec = (
16412 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16413 
  )
16414 
 
16415 
  def __init__(self, success=None,):
16416 
    self.success = success
16417 
 
16418 
  def read(self, iprot):
16419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16421 
      return
16422 
    iprot.readStructBegin()
16423 
    while True:
16424 
      (fname, ftype, fid) = iprot.readFieldBegin()
16425 
      if ftype == TType.STOP:
16426 
        break
16427 
      if fid == 0:
16428 
        if ftype == TType.LIST:
16429 
          self.success = []
5386 phani.kuma 16430 
          (_etype371, _size368) = iprot.readListBegin()
16431 
          for _i372 in xrange(_size368):
16432 
            _elem373 = ReturnOrder()
16433 
            _elem373.read(iprot)
16434 
            self.success.append(_elem373)
2690 chandransh 16435 
          iprot.readListEnd()
16436 
        else:
16437 
          iprot.skip(ftype)
16438 
      else:
16439 
        iprot.skip(ftype)
16440 
      iprot.readFieldEnd()
16441 
    iprot.readStructEnd()
16442 
 
16443 
  def write(self, oprot):
16444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16446 
      return
16447 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16448 
    if self.success is not None:
2690 chandransh 16449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 16451 
      for iter374 in self.success:
16452 
        iter374.write(oprot)
2690 chandransh 16453 
      oprot.writeListEnd()
16454 
      oprot.writeFieldEnd()
16455 
    oprot.writeFieldStop()
16456 
    oprot.writeStructEnd()
16457 
 
3431 rajveer 16458 
  def validate(self):
16459 
    return
16460 
 
16461 
 
2690 chandransh 16462 
  def __repr__(self):
16463 
    L = ['%s=%r' % (key, value)
16464 
      for key, value in self.__dict__.iteritems()]
16465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16466 
 
16467 
  def __eq__(self, other):
16468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16469 
 
16470 
  def __ne__(self, other):
16471 
    return not (self == other)
16472 
 
2700 chandransh 16473 
class getReturnOrder_args:
16474 
  """
16475 
  Attributes:
16476 
   - id
16477 
  """
16478 
 
16479 
  thrift_spec = (
16480 
    None, # 0
16481 
    (1, TType.I64, 'id', None, None, ), # 1
16482 
  )
16483 
 
16484 
  def __init__(self, id=None,):
16485 
    self.id = id
16486 
 
16487 
  def read(self, iprot):
16488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16490 
      return
16491 
    iprot.readStructBegin()
16492 
    while True:
16493 
      (fname, ftype, fid) = iprot.readFieldBegin()
16494 
      if ftype == TType.STOP:
16495 
        break
16496 
      if fid == 1:
16497 
        if ftype == TType.I64:
16498 
          self.id = iprot.readI64();
16499 
        else:
16500 
          iprot.skip(ftype)
16501 
      else:
16502 
        iprot.skip(ftype)
16503 
      iprot.readFieldEnd()
16504 
    iprot.readStructEnd()
16505 
 
16506 
  def write(self, oprot):
16507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16509 
      return
16510 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16511 
    if self.id is not None:
2700 chandransh 16512 
      oprot.writeFieldBegin('id', TType.I64, 1)
16513 
      oprot.writeI64(self.id)
16514 
      oprot.writeFieldEnd()
16515 
    oprot.writeFieldStop()
16516 
    oprot.writeStructEnd()
16517 
 
3431 rajveer 16518 
  def validate(self):
16519 
    return
16520 
 
16521 
 
2700 chandransh 16522 
  def __repr__(self):
16523 
    L = ['%s=%r' % (key, value)
16524 
      for key, value in self.__dict__.iteritems()]
16525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16526 
 
16527 
  def __eq__(self, other):
16528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16529 
 
16530 
  def __ne__(self, other):
16531 
    return not (self == other)
16532 
 
16533 
class getReturnOrder_result:
16534 
  """
16535 
  Attributes:
16536 
   - success
16537 
   - ex
16538 
  """
16539 
 
16540 
  thrift_spec = (
16541 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16543 
  )
16544 
 
16545 
  def __init__(self, success=None, ex=None,):
16546 
    self.success = success
16547 
    self.ex = ex
16548 
 
16549 
  def read(self, iprot):
16550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16552 
      return
16553 
    iprot.readStructBegin()
16554 
    while True:
16555 
      (fname, ftype, fid) = iprot.readFieldBegin()
16556 
      if ftype == TType.STOP:
16557 
        break
16558 
      if fid == 0:
16559 
        if ftype == TType.STRUCT:
16560 
          self.success = ReturnOrder()
16561 
          self.success.read(iprot)
16562 
        else:
16563 
          iprot.skip(ftype)
16564 
      elif fid == 1:
16565 
        if ftype == TType.STRUCT:
16566 
          self.ex = TransactionServiceException()
16567 
          self.ex.read(iprot)
16568 
        else:
16569 
          iprot.skip(ftype)
16570 
      else:
16571 
        iprot.skip(ftype)
16572 
      iprot.readFieldEnd()
16573 
    iprot.readStructEnd()
16574 
 
16575 
  def write(self, oprot):
16576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16578 
      return
16579 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16580 
    if self.success is not None:
2700 chandransh 16581 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16582 
      self.success.write(oprot)
16583 
      oprot.writeFieldEnd()
3431 rajveer 16584 
    if self.ex is not None:
2700 chandransh 16585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16586 
      self.ex.write(oprot)
16587 
      oprot.writeFieldEnd()
16588 
    oprot.writeFieldStop()
16589 
    oprot.writeStructEnd()
16590 
 
3431 rajveer 16591 
  def validate(self):
16592 
    return
16593 
 
16594 
 
2700 chandransh 16595 
  def __repr__(self):
16596 
    L = ['%s=%r' % (key, value)
16597 
      for key, value in self.__dict__.iteritems()]
16598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16599 
 
16600 
  def __eq__(self, other):
16601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16602 
 
16603 
  def __ne__(self, other):
16604 
    return not (self == other)
16605 
 
2690 chandransh 16606 
class processReturn_args:
16607 
  """
16608 
  Attributes:
16609 
   - returnOrderId
16610 
  """
16611 
 
16612 
  thrift_spec = (
16613 
    None, # 0
16614 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16615 
  )
16616 
 
16617 
  def __init__(self, returnOrderId=None,):
16618 
    self.returnOrderId = returnOrderId
16619 
 
16620 
  def read(self, iprot):
16621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16623 
      return
16624 
    iprot.readStructBegin()
16625 
    while True:
16626 
      (fname, ftype, fid) = iprot.readFieldBegin()
16627 
      if ftype == TType.STOP:
16628 
        break
16629 
      if fid == 1:
16630 
        if ftype == TType.I64:
16631 
          self.returnOrderId = iprot.readI64();
16632 
        else:
16633 
          iprot.skip(ftype)
16634 
      else:
16635 
        iprot.skip(ftype)
16636 
      iprot.readFieldEnd()
16637 
    iprot.readStructEnd()
16638 
 
16639 
  def write(self, oprot):
16640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16642 
      return
16643 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16644 
    if self.returnOrderId is not None:
2690 chandransh 16645 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16646 
      oprot.writeI64(self.returnOrderId)
16647 
      oprot.writeFieldEnd()
16648 
    oprot.writeFieldStop()
16649 
    oprot.writeStructEnd()
16650 
 
3431 rajveer 16651 
  def validate(self):
16652 
    return
16653 
 
16654 
 
2690 chandransh 16655 
  def __repr__(self):
16656 
    L = ['%s=%r' % (key, value)
16657 
      for key, value in self.__dict__.iteritems()]
16658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16659 
 
16660 
  def __eq__(self, other):
16661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16662 
 
16663 
  def __ne__(self, other):
16664 
    return not (self == other)
16665 
 
16666 
class processReturn_result:
16667 
  """
16668 
  Attributes:
16669 
   - ex
16670 
  """
16671 
 
16672 
  thrift_spec = (
16673 
    None, # 0
16674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16675 
  )
16676 
 
16677 
  def __init__(self, ex=None,):
16678 
    self.ex = ex
16679 
 
16680 
  def read(self, iprot):
16681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16683 
      return
16684 
    iprot.readStructBegin()
16685 
    while True:
16686 
      (fname, ftype, fid) = iprot.readFieldBegin()
16687 
      if ftype == TType.STOP:
16688 
        break
16689 
      if fid == 1:
16690 
        if ftype == TType.STRUCT:
16691 
          self.ex = TransactionServiceException()
16692 
          self.ex.read(iprot)
16693 
        else:
16694 
          iprot.skip(ftype)
16695 
      else:
16696 
        iprot.skip(ftype)
16697 
      iprot.readFieldEnd()
16698 
    iprot.readStructEnd()
16699 
 
16700 
  def write(self, oprot):
16701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16703 
      return
16704 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16705 
    if self.ex is not None:
2690 chandransh 16706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16707 
      self.ex.write(oprot)
16708 
      oprot.writeFieldEnd()
16709 
    oprot.writeFieldStop()
16710 
    oprot.writeStructEnd()
16711 
 
3431 rajveer 16712 
  def validate(self):
16713 
    return
16714 
 
16715 
 
2690 chandransh 16716 
  def __repr__(self):
16717 
    L = ['%s=%r' % (key, value)
16718 
      for key, value in self.__dict__.iteritems()]
16719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16720 
 
16721 
  def __eq__(self, other):
16722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16723 
 
16724 
  def __ne__(self, other):
16725 
    return not (self == other)
16726 
 
3451 chandransh 16727 
class updateWeight_args:
16728 
  """
16729 
  Attributes:
16730 
   - orderId
16731 
   - weight
16732 
  """
16733 
 
16734 
  thrift_spec = (
16735 
    None, # 0
16736 
    (1, TType.I64, 'orderId', None, None, ), # 1
16737 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16738 
  )
16739 
 
16740 
  def __init__(self, orderId=None, weight=None,):
16741 
    self.orderId = orderId
16742 
    self.weight = weight
16743 
 
16744 
  def read(self, iprot):
16745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16747 
      return
16748 
    iprot.readStructBegin()
16749 
    while True:
16750 
      (fname, ftype, fid) = iprot.readFieldBegin()
16751 
      if ftype == TType.STOP:
16752 
        break
16753 
      if fid == 1:
16754 
        if ftype == TType.I64:
16755 
          self.orderId = iprot.readI64();
16756 
        else:
16757 
          iprot.skip(ftype)
16758 
      elif fid == 2:
16759 
        if ftype == TType.DOUBLE:
16760 
          self.weight = iprot.readDouble();
16761 
        else:
16762 
          iprot.skip(ftype)
16763 
      else:
16764 
        iprot.skip(ftype)
16765 
      iprot.readFieldEnd()
16766 
    iprot.readStructEnd()
16767 
 
16768 
  def write(self, oprot):
16769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16771 
      return
16772 
    oprot.writeStructBegin('updateWeight_args')
16773 
    if self.orderId is not None:
16774 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16775 
      oprot.writeI64(self.orderId)
16776 
      oprot.writeFieldEnd()
16777 
    if self.weight is not None:
16778 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16779 
      oprot.writeDouble(self.weight)
16780 
      oprot.writeFieldEnd()
16781 
    oprot.writeFieldStop()
16782 
    oprot.writeStructEnd()
16783 
 
16784 
  def validate(self):
16785 
    return
16786 
 
16787 
 
16788 
  def __repr__(self):
16789 
    L = ['%s=%r' % (key, value)
16790 
      for key, value in self.__dict__.iteritems()]
16791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16792 
 
16793 
  def __eq__(self, other):
16794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16795 
 
16796 
  def __ne__(self, other):
16797 
    return not (self == other)
16798 
 
16799 
class updateWeight_result:
16800 
  """
16801 
  Attributes:
16802 
   - success
16803 
   - ex
16804 
  """
16805 
 
16806 
  thrift_spec = (
16807 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16809 
  )
16810 
 
16811 
  def __init__(self, success=None, ex=None,):
16812 
    self.success = success
16813 
    self.ex = ex
16814 
 
16815 
  def read(self, iprot):
16816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16818 
      return
16819 
    iprot.readStructBegin()
16820 
    while True:
16821 
      (fname, ftype, fid) = iprot.readFieldBegin()
16822 
      if ftype == TType.STOP:
16823 
        break
16824 
      if fid == 0:
16825 
        if ftype == TType.STRUCT:
16826 
          self.success = Order()
16827 
          self.success.read(iprot)
16828 
        else:
16829 
          iprot.skip(ftype)
16830 
      elif fid == 1:
16831 
        if ftype == TType.STRUCT:
16832 
          self.ex = TransactionServiceException()
16833 
          self.ex.read(iprot)
16834 
        else:
16835 
          iprot.skip(ftype)
16836 
      else:
16837 
        iprot.skip(ftype)
16838 
      iprot.readFieldEnd()
16839 
    iprot.readStructEnd()
16840 
 
16841 
  def write(self, oprot):
16842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16844 
      return
16845 
    oprot.writeStructBegin('updateWeight_result')
16846 
    if self.success is not None:
16847 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16848 
      self.success.write(oprot)
16849 
      oprot.writeFieldEnd()
16850 
    if self.ex is not None:
16851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16852 
      self.ex.write(oprot)
16853 
      oprot.writeFieldEnd()
16854 
    oprot.writeFieldStop()
16855 
    oprot.writeStructEnd()
16856 
 
16857 
  def validate(self):
16858 
    return
16859 
 
16860 
 
16861 
  def __repr__(self):
16862 
    L = ['%s=%r' % (key, value)
16863 
      for key, value in self.__dict__.iteritems()]
16864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16865 
 
16866 
  def __eq__(self, other):
16867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16868 
 
16869 
  def __ne__(self, other):
16870 
    return not (self == other)
3469 chandransh 16871 
 
16872 
class changeItem_args:
16873 
  """
16874 
  Attributes:
16875 
   - orderId
16876 
   - itemId
16877 
  """
16878 
 
16879 
  thrift_spec = (
16880 
    None, # 0
16881 
    (1, TType.I64, 'orderId', None, None, ), # 1
16882 
    (2, TType.I64, 'itemId', None, None, ), # 2
16883 
  )
16884 
 
16885 
  def __init__(self, orderId=None, itemId=None,):
16886 
    self.orderId = orderId
16887 
    self.itemId = itemId
16888 
 
16889 
  def read(self, iprot):
16890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16892 
      return
16893 
    iprot.readStructBegin()
16894 
    while True:
16895 
      (fname, ftype, fid) = iprot.readFieldBegin()
16896 
      if ftype == TType.STOP:
16897 
        break
16898 
      if fid == 1:
16899 
        if ftype == TType.I64:
16900 
          self.orderId = iprot.readI64();
16901 
        else:
16902 
          iprot.skip(ftype)
16903 
      elif fid == 2:
16904 
        if ftype == TType.I64:
16905 
          self.itemId = iprot.readI64();
16906 
        else:
16907 
          iprot.skip(ftype)
16908 
      else:
16909 
        iprot.skip(ftype)
16910 
      iprot.readFieldEnd()
16911 
    iprot.readStructEnd()
16912 
 
16913 
  def write(self, oprot):
16914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16916 
      return
16917 
    oprot.writeStructBegin('changeItem_args')
16918 
    if self.orderId is not None:
16919 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16920 
      oprot.writeI64(self.orderId)
16921 
      oprot.writeFieldEnd()
16922 
    if self.itemId is not None:
16923 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16924 
      oprot.writeI64(self.itemId)
16925 
      oprot.writeFieldEnd()
16926 
    oprot.writeFieldStop()
16927 
    oprot.writeStructEnd()
16928 
 
16929 
  def validate(self):
16930 
    return
16931 
 
16932 
 
16933 
  def __repr__(self):
16934 
    L = ['%s=%r' % (key, value)
16935 
      for key, value in self.__dict__.iteritems()]
16936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16937 
 
16938 
  def __eq__(self, other):
16939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16940 
 
16941 
  def __ne__(self, other):
16942 
    return not (self == other)
16943 
 
16944 
class changeItem_result:
16945 
  """
16946 
  Attributes:
16947 
   - success
16948 
   - ex
16949 
  """
16950 
 
16951 
  thrift_spec = (
16952 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16954 
  )
16955 
 
16956 
  def __init__(self, success=None, ex=None,):
16957 
    self.success = success
16958 
    self.ex = ex
16959 
 
16960 
  def read(self, iprot):
16961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16963 
      return
16964 
    iprot.readStructBegin()
16965 
    while True:
16966 
      (fname, ftype, fid) = iprot.readFieldBegin()
16967 
      if ftype == TType.STOP:
16968 
        break
16969 
      if fid == 0:
16970 
        if ftype == TType.STRUCT:
16971 
          self.success = Order()
16972 
          self.success.read(iprot)
16973 
        else:
16974 
          iprot.skip(ftype)
16975 
      elif fid == 1:
16976 
        if ftype == TType.STRUCT:
16977 
          self.ex = TransactionServiceException()
16978 
          self.ex.read(iprot)
16979 
        else:
16980 
          iprot.skip(ftype)
16981 
      else:
16982 
        iprot.skip(ftype)
16983 
      iprot.readFieldEnd()
16984 
    iprot.readStructEnd()
16985 
 
16986 
  def write(self, oprot):
16987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16989 
      return
16990 
    oprot.writeStructBegin('changeItem_result')
16991 
    if self.success is not None:
16992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16993 
      self.success.write(oprot)
16994 
      oprot.writeFieldEnd()
16995 
    if self.ex is not None:
16996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16997 
      self.ex.write(oprot)
16998 
      oprot.writeFieldEnd()
16999 
    oprot.writeFieldStop()
17000 
    oprot.writeStructEnd()
17001 
 
17002 
  def validate(self):
17003 
    return
17004 
 
17005 
 
17006 
  def __repr__(self):
17007 
    L = ['%s=%r' % (key, value)
17008 
      for key, value in self.__dict__.iteritems()]
17009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17010 
 
17011 
  def __eq__(self, other):
17012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17013 
 
17014 
  def __ne__(self, other):
17015 
    return not (self == other)
17016 
 
17017 
class shiftToWarehouse_args:
17018 
  """
17019 
  Attributes:
17020 
   - orderId
17021 
   - warehouseId
17022 
  """
17023 
 
17024 
  thrift_spec = (
17025 
    None, # 0
17026 
    (1, TType.I64, 'orderId', None, None, ), # 1
17027 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17028 
  )
17029 
 
17030 
  def __init__(self, orderId=None, warehouseId=None,):
17031 
    self.orderId = orderId
17032 
    self.warehouseId = warehouseId
17033 
 
17034 
  def read(self, iprot):
17035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17037 
      return
17038 
    iprot.readStructBegin()
17039 
    while True:
17040 
      (fname, ftype, fid) = iprot.readFieldBegin()
17041 
      if ftype == TType.STOP:
17042 
        break
17043 
      if fid == 1:
17044 
        if ftype == TType.I64:
17045 
          self.orderId = iprot.readI64();
17046 
        else:
17047 
          iprot.skip(ftype)
17048 
      elif fid == 2:
17049 
        if ftype == TType.I64:
17050 
          self.warehouseId = iprot.readI64();
17051 
        else:
17052 
          iprot.skip(ftype)
17053 
      else:
17054 
        iprot.skip(ftype)
17055 
      iprot.readFieldEnd()
17056 
    iprot.readStructEnd()
17057 
 
17058 
  def write(self, oprot):
17059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17061 
      return
17062 
    oprot.writeStructBegin('shiftToWarehouse_args')
17063 
    if self.orderId is not None:
17064 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17065 
      oprot.writeI64(self.orderId)
17066 
      oprot.writeFieldEnd()
17067 
    if self.warehouseId is not None:
17068 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17069 
      oprot.writeI64(self.warehouseId)
17070 
      oprot.writeFieldEnd()
17071 
    oprot.writeFieldStop()
17072 
    oprot.writeStructEnd()
17073 
 
17074 
  def validate(self):
17075 
    return
17076 
 
17077 
 
17078 
  def __repr__(self):
17079 
    L = ['%s=%r' % (key, value)
17080 
      for key, value in self.__dict__.iteritems()]
17081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17082 
 
17083 
  def __eq__(self, other):
17084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17085 
 
17086 
  def __ne__(self, other):
17087 
    return not (self == other)
17088 
 
17089 
class shiftToWarehouse_result:
17090 
  """
17091 
  Attributes:
17092 
   - success
17093 
   - ex
17094 
  """
17095 
 
17096 
  thrift_spec = (
17097 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17099 
  )
17100 
 
17101 
  def __init__(self, success=None, ex=None,):
17102 
    self.success = success
17103 
    self.ex = ex
17104 
 
17105 
  def read(self, iprot):
17106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17108 
      return
17109 
    iprot.readStructBegin()
17110 
    while True:
17111 
      (fname, ftype, fid) = iprot.readFieldBegin()
17112 
      if ftype == TType.STOP:
17113 
        break
17114 
      if fid == 0:
17115 
        if ftype == TType.STRUCT:
17116 
          self.success = Order()
17117 
          self.success.read(iprot)
17118 
        else:
17119 
          iprot.skip(ftype)
17120 
      elif fid == 1:
17121 
        if ftype == TType.STRUCT:
17122 
          self.ex = TransactionServiceException()
17123 
          self.ex.read(iprot)
17124 
        else:
17125 
          iprot.skip(ftype)
17126 
      else:
17127 
        iprot.skip(ftype)
17128 
      iprot.readFieldEnd()
17129 
    iprot.readStructEnd()
17130 
 
17131 
  def write(self, oprot):
17132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17134 
      return
17135 
    oprot.writeStructBegin('shiftToWarehouse_result')
17136 
    if self.success is not None:
17137 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17138 
      self.success.write(oprot)
17139 
      oprot.writeFieldEnd()
17140 
    if self.ex is not None:
17141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17142 
      self.ex.write(oprot)
17143 
      oprot.writeFieldEnd()
17144 
    oprot.writeFieldStop()
17145 
    oprot.writeStructEnd()
17146 
 
17147 
  def validate(self):
17148 
    return
17149 
 
17150 
 
17151 
  def __repr__(self):
17152 
    L = ['%s=%r' % (key, value)
17153 
      for key, value in self.__dict__.iteritems()]
17154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17155 
 
17156 
  def __eq__(self, other):
17157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17158 
 
17159 
  def __ne__(self, other):
17160 
    return not (self == other)
3553 chandransh 17161 
 
17162 
class addDelayReason_args:
17163 
  """
17164 
  Attributes:
17165 
   - orderId
17166 
   - delayReason
3986 chandransh 17167 
   - furtherDelay
4647 rajveer 17168 
   - delayReasonText
3553 chandransh 17169 
  """
17170 
 
17171 
  thrift_spec = (
17172 
    None, # 0
17173 
    (1, TType.I64, 'orderId', None, None, ), # 1
17174 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17175 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17176 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17177 
  )
17178 
 
4647 rajveer 17179 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17180 
    self.orderId = orderId
17181 
    self.delayReason = delayReason
3986 chandransh 17182 
    self.furtherDelay = furtherDelay
4647 rajveer 17183 
    self.delayReasonText = delayReasonText
3553 chandransh 17184 
 
17185 
  def read(self, iprot):
17186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17188 
      return
17189 
    iprot.readStructBegin()
17190 
    while True:
17191 
      (fname, ftype, fid) = iprot.readFieldBegin()
17192 
      if ftype == TType.STOP:
17193 
        break
17194 
      if fid == 1:
17195 
        if ftype == TType.I64:
17196 
          self.orderId = iprot.readI64();
17197 
        else:
17198 
          iprot.skip(ftype)
17199 
      elif fid == 2:
17200 
        if ftype == TType.I32:
17201 
          self.delayReason = iprot.readI32();
17202 
        else:
17203 
          iprot.skip(ftype)
3986 chandransh 17204 
      elif fid == 3:
17205 
        if ftype == TType.I64:
17206 
          self.furtherDelay = iprot.readI64();
17207 
        else:
17208 
          iprot.skip(ftype)
4647 rajveer 17209 
      elif fid == 4:
17210 
        if ftype == TType.STRING:
17211 
          self.delayReasonText = iprot.readString();
17212 
        else:
17213 
          iprot.skip(ftype)
3553 chandransh 17214 
      else:
17215 
        iprot.skip(ftype)
17216 
      iprot.readFieldEnd()
17217 
    iprot.readStructEnd()
17218 
 
17219 
  def write(self, oprot):
17220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17222 
      return
17223 
    oprot.writeStructBegin('addDelayReason_args')
17224 
    if self.orderId is not None:
17225 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17226 
      oprot.writeI64(self.orderId)
17227 
      oprot.writeFieldEnd()
17228 
    if self.delayReason is not None:
17229 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17230 
      oprot.writeI32(self.delayReason)
17231 
      oprot.writeFieldEnd()
3986 chandransh 17232 
    if self.furtherDelay is not None:
17233 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17234 
      oprot.writeI64(self.furtherDelay)
17235 
      oprot.writeFieldEnd()
4647 rajveer 17236 
    if self.delayReasonText is not None:
17237 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17238 
      oprot.writeString(self.delayReasonText)
17239 
      oprot.writeFieldEnd()
3553 chandransh 17240 
    oprot.writeFieldStop()
17241 
    oprot.writeStructEnd()
17242 
 
17243 
  def validate(self):
17244 
    return
17245 
 
17246 
 
17247 
  def __repr__(self):
17248 
    L = ['%s=%r' % (key, value)
17249 
      for key, value in self.__dict__.iteritems()]
17250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17251 
 
17252 
  def __eq__(self, other):
17253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17254 
 
17255 
  def __ne__(self, other):
17256 
    return not (self == other)
17257 
 
17258 
class addDelayReason_result:
17259 
  """
17260 
  Attributes:
17261 
   - success
17262 
   - ex
17263 
  """
17264 
 
17265 
  thrift_spec = (
17266 
    (0, TType.BOOL, 'success', None, None, ), # 0
17267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17268 
  )
17269 
 
17270 
  def __init__(self, success=None, ex=None,):
17271 
    self.success = success
17272 
    self.ex = ex
17273 
 
17274 
  def read(self, iprot):
17275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17277 
      return
17278 
    iprot.readStructBegin()
17279 
    while True:
17280 
      (fname, ftype, fid) = iprot.readFieldBegin()
17281 
      if ftype == TType.STOP:
17282 
        break
17283 
      if fid == 0:
17284 
        if ftype == TType.BOOL:
17285 
          self.success = iprot.readBool();
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      elif fid == 1:
17289 
        if ftype == TType.STRUCT:
17290 
          self.ex = TransactionServiceException()
17291 
          self.ex.read(iprot)
17292 
        else:
17293 
          iprot.skip(ftype)
17294 
      else:
17295 
        iprot.skip(ftype)
17296 
      iprot.readFieldEnd()
17297 
    iprot.readStructEnd()
17298 
 
17299 
  def write(self, oprot):
17300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17302 
      return
17303 
    oprot.writeStructBegin('addDelayReason_result')
17304 
    if self.success is not None:
17305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17306 
      oprot.writeBool(self.success)
17307 
      oprot.writeFieldEnd()
17308 
    if self.ex is not None:
17309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17310 
      self.ex.write(oprot)
17311 
      oprot.writeFieldEnd()
17312 
    oprot.writeFieldStop()
17313 
    oprot.writeStructEnd()
17314 
 
17315 
  def validate(self):
17316 
    return
17317 
 
17318 
 
17319 
  def __repr__(self):
17320 
    L = ['%s=%r' % (key, value)
17321 
      for key, value in self.__dict__.iteritems()]
17322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17323 
 
17324 
  def __eq__(self, other):
17325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17326 
 
17327 
  def __ne__(self, other):
17328 
    return not (self == other)
3956 chandransh 17329 
 
17330 
class reconcileCodCollection_args:
17331 
  """
17332 
  Attributes:
17333 
   - collectedAmountMap
17334 
   - xferBy
17335 
   - xferTxnId
17336 
   - xferDate
17337 
  """
17338 
 
17339 
  thrift_spec = (
17340 
    None, # 0
17341 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17342 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17343 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17344 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17345 
  )
17346 
 
17347 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17348 
    self.collectedAmountMap = collectedAmountMap
17349 
    self.xferBy = xferBy
17350 
    self.xferTxnId = xferTxnId
17351 
    self.xferDate = xferDate
17352 
 
17353 
  def read(self, iprot):
17354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17356 
      return
17357 
    iprot.readStructBegin()
17358 
    while True:
17359 
      (fname, ftype, fid) = iprot.readFieldBegin()
17360 
      if ftype == TType.STOP:
17361 
        break
17362 
      if fid == 1:
17363 
        if ftype == TType.MAP:
17364 
          self.collectedAmountMap = {}
5386 phani.kuma 17365 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
17366 
          for _i379 in xrange(_size375):
17367 
            _key380 = iprot.readString();
17368 
            _val381 = iprot.readDouble();
17369 
            self.collectedAmountMap[_key380] = _val381
3956 chandransh 17370 
          iprot.readMapEnd()
17371 
        else:
17372 
          iprot.skip(ftype)
17373 
      elif fid == 2:
17374 
        if ftype == TType.STRING:
17375 
          self.xferBy = iprot.readString();
17376 
        else:
17377 
          iprot.skip(ftype)
17378 
      elif fid == 3:
17379 
        if ftype == TType.STRING:
17380 
          self.xferTxnId = iprot.readString();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      elif fid == 4:
17384 
        if ftype == TType.I64:
17385 
          self.xferDate = iprot.readI64();
17386 
        else:
17387 
          iprot.skip(ftype)
17388 
      else:
17389 
        iprot.skip(ftype)
17390 
      iprot.readFieldEnd()
17391 
    iprot.readStructEnd()
17392 
 
17393 
  def write(self, oprot):
17394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17396 
      return
17397 
    oprot.writeStructBegin('reconcileCodCollection_args')
17398 
    if self.collectedAmountMap is not None:
17399 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17400 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5386 phani.kuma 17401 
      for kiter382,viter383 in self.collectedAmountMap.items():
17402 
        oprot.writeString(kiter382)
17403 
        oprot.writeDouble(viter383)
3956 chandransh 17404 
      oprot.writeMapEnd()
17405 
      oprot.writeFieldEnd()
17406 
    if self.xferBy is not None:
17407 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17408 
      oprot.writeString(self.xferBy)
17409 
      oprot.writeFieldEnd()
17410 
    if self.xferTxnId is not None:
17411 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17412 
      oprot.writeString(self.xferTxnId)
17413 
      oprot.writeFieldEnd()
17414 
    if self.xferDate is not None:
17415 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17416 
      oprot.writeI64(self.xferDate)
17417 
      oprot.writeFieldEnd()
17418 
    oprot.writeFieldStop()
17419 
    oprot.writeStructEnd()
17420 
 
17421 
  def validate(self):
17422 
    return
17423 
 
17424 
 
17425 
  def __repr__(self):
17426 
    L = ['%s=%r' % (key, value)
17427 
      for key, value in self.__dict__.iteritems()]
17428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17429 
 
17430 
  def __eq__(self, other):
17431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17432 
 
17433 
  def __ne__(self, other):
17434 
    return not (self == other)
17435 
 
17436 
class reconcileCodCollection_result:
17437 
  """
17438 
  Attributes:
17439 
   - success
17440 
   - ex
17441 
  """
17442 
 
17443 
  thrift_spec = (
17444 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17446 
  )
17447 
 
17448 
  def __init__(self, success=None, ex=None,):
17449 
    self.success = success
17450 
    self.ex = ex
17451 
 
17452 
  def read(self, iprot):
17453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17455 
      return
17456 
    iprot.readStructBegin()
17457 
    while True:
17458 
      (fname, ftype, fid) = iprot.readFieldBegin()
17459 
      if ftype == TType.STOP:
17460 
        break
17461 
      if fid == 0:
17462 
        if ftype == TType.MAP:
17463 
          self.success = {}
5386 phani.kuma 17464 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
17465 
          for _i388 in xrange(_size384):
17466 
            _key389 = iprot.readString();
17467 
            _val390 = iprot.readString();
17468 
            self.success[_key389] = _val390
3956 chandransh 17469 
          iprot.readMapEnd()
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 1:
17473 
        if ftype == TType.STRUCT:
17474 
          self.ex = TransactionServiceException()
17475 
          self.ex.read(iprot)
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      else:
17479 
        iprot.skip(ftype)
17480 
      iprot.readFieldEnd()
17481 
    iprot.readStructEnd()
17482 
 
17483 
  def write(self, oprot):
17484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17486 
      return
17487 
    oprot.writeStructBegin('reconcileCodCollection_result')
17488 
    if self.success is not None:
17489 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17490 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5386 phani.kuma 17491 
      for kiter391,viter392 in self.success.items():
17492 
        oprot.writeString(kiter391)
17493 
        oprot.writeString(viter392)
3956 chandransh 17494 
      oprot.writeMapEnd()
17495 
      oprot.writeFieldEnd()
17496 
    if self.ex is not None:
17497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17498 
      self.ex.write(oprot)
17499 
      oprot.writeFieldEnd()
17500 
    oprot.writeFieldStop()
17501 
    oprot.writeStructEnd()
17502 
 
17503 
  def validate(self):
17504 
    return
17505 
 
17506 
 
17507 
  def __repr__(self):
17508 
    L = ['%s=%r' % (key, value)
17509 
      for key, value in self.__dict__.iteritems()]
17510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17511 
 
17512 
  def __eq__(self, other):
17513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17514 
 
17515 
  def __ne__(self, other):
17516 
    return not (self == other)
4008 mandeep.dh 17517 
 
17518 
class getTransactionsRequiringExtraProcessing_args:
17519 
  """
17520 
  Attributes:
17521 
   - category
17522 
  """
17523 
 
17524 
  thrift_spec = (
17525 
    None, # 0
17526 
    (1, TType.I32, 'category', None, None, ), # 1
17527 
  )
17528 
 
17529 
  def __init__(self, category=None,):
17530 
    self.category = category
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 == 1:
17542 
        if ftype == TType.I32:
17543 
          self.category = iprot.readI32();
17544 
        else:
17545 
          iprot.skip(ftype)
17546 
      else:
17547 
        iprot.skip(ftype)
17548 
      iprot.readFieldEnd()
17549 
    iprot.readStructEnd()
17550 
 
17551 
  def write(self, oprot):
17552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17554 
      return
17555 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17556 
    if self.category is not None:
17557 
      oprot.writeFieldBegin('category', TType.I32, 1)
17558 
      oprot.writeI32(self.category)
17559 
      oprot.writeFieldEnd()
17560 
    oprot.writeFieldStop()
17561 
    oprot.writeStructEnd()
17562 
 
17563 
  def validate(self):
17564 
    return
17565 
 
17566 
 
17567 
  def __repr__(self):
17568 
    L = ['%s=%r' % (key, value)
17569 
      for key, value in self.__dict__.iteritems()]
17570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17571 
 
17572 
  def __eq__(self, other):
17573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17574 
 
17575 
  def __ne__(self, other):
17576 
    return not (self == other)
17577 
 
17578 
class getTransactionsRequiringExtraProcessing_result:
17579 
  """
17580 
  Attributes:
17581 
   - success
17582 
  """
17583 
 
17584 
  thrift_spec = (
17585 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17586 
  )
17587 
 
17588 
  def __init__(self, success=None,):
17589 
    self.success = success
17590 
 
17591 
  def read(self, iprot):
17592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17594 
      return
17595 
    iprot.readStructBegin()
17596 
    while True:
17597 
      (fname, ftype, fid) = iprot.readFieldBegin()
17598 
      if ftype == TType.STOP:
17599 
        break
17600 
      if fid == 0:
17601 
        if ftype == TType.LIST:
17602 
          self.success = []
5386 phani.kuma 17603 
          (_etype396, _size393) = iprot.readListBegin()
17604 
          for _i397 in xrange(_size393):
17605 
            _elem398 = iprot.readI64();
17606 
            self.success.append(_elem398)
4008 mandeep.dh 17607 
          iprot.readListEnd()
17608 
        else:
17609 
          iprot.skip(ftype)
17610 
      else:
17611 
        iprot.skip(ftype)
17612 
      iprot.readFieldEnd()
17613 
    iprot.readStructEnd()
17614 
 
17615 
  def write(self, oprot):
17616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17618 
      return
17619 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17620 
    if self.success is not None:
17621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17622 
      oprot.writeListBegin(TType.I64, len(self.success))
5386 phani.kuma 17623 
      for iter399 in self.success:
17624 
        oprot.writeI64(iter399)
4008 mandeep.dh 17625 
      oprot.writeListEnd()
17626 
      oprot.writeFieldEnd()
17627 
    oprot.writeFieldStop()
17628 
    oprot.writeStructEnd()
17629 
 
17630 
  def validate(self):
17631 
    return
17632 
 
17633 
 
17634 
  def __repr__(self):
17635 
    L = ['%s=%r' % (key, value)
17636 
      for key, value in self.__dict__.iteritems()]
17637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17638 
 
17639 
  def __eq__(self, other):
17640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17641 
 
17642 
  def __ne__(self, other):
17643 
    return not (self == other)
17644 
 
17645 
class markTransactionAsProcessed_args:
17646 
  """
17647 
  Attributes:
17648 
   - transactionId
17649 
   - category
17650 
  """
17651 
 
17652 
  thrift_spec = (
17653 
    None, # 0
17654 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17655 
    (2, TType.I32, 'category', None, None, ), # 2
17656 
  )
17657 
 
17658 
  def __init__(self, transactionId=None, category=None,):
17659 
    self.transactionId = transactionId
17660 
    self.category = category
17661 
 
17662 
  def read(self, iprot):
17663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17665 
      return
17666 
    iprot.readStructBegin()
17667 
    while True:
17668 
      (fname, ftype, fid) = iprot.readFieldBegin()
17669 
      if ftype == TType.STOP:
17670 
        break
17671 
      if fid == 1:
17672 
        if ftype == TType.I64:
17673 
          self.transactionId = iprot.readI64();
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      elif fid == 2:
17677 
        if ftype == TType.I32:
17678 
          self.category = iprot.readI32();
17679 
        else:
17680 
          iprot.skip(ftype)
17681 
      else:
17682 
        iprot.skip(ftype)
17683 
      iprot.readFieldEnd()
17684 
    iprot.readStructEnd()
17685 
 
17686 
  def write(self, oprot):
17687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17689 
      return
17690 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17691 
    if self.transactionId is not None:
17692 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17693 
      oprot.writeI64(self.transactionId)
17694 
      oprot.writeFieldEnd()
17695 
    if self.category is not None:
17696 
      oprot.writeFieldBegin('category', TType.I32, 2)
17697 
      oprot.writeI32(self.category)
17698 
      oprot.writeFieldEnd()
17699 
    oprot.writeFieldStop()
17700 
    oprot.writeStructEnd()
17701 
 
17702 
  def validate(self):
17703 
    return
17704 
 
17705 
 
17706 
  def __repr__(self):
17707 
    L = ['%s=%r' % (key, value)
17708 
      for key, value in self.__dict__.iteritems()]
17709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17710 
 
17711 
  def __eq__(self, other):
17712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17713 
 
17714 
  def __ne__(self, other):
17715 
    return not (self == other)
17716 
 
17717 
class markTransactionAsProcessed_result:
17718 
 
17719 
  thrift_spec = (
17720 
  )
17721 
 
17722 
  def read(self, iprot):
17723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17725 
      return
17726 
    iprot.readStructBegin()
17727 
    while True:
17728 
      (fname, ftype, fid) = iprot.readFieldBegin()
17729 
      if ftype == TType.STOP:
17730 
        break
17731 
      else:
17732 
        iprot.skip(ftype)
17733 
      iprot.readFieldEnd()
17734 
    iprot.readStructEnd()
17735 
 
17736 
  def write(self, oprot):
17737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17739 
      return
17740 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17741 
    oprot.writeFieldStop()
17742 
    oprot.writeStructEnd()
17743 
 
17744 
  def validate(self):
17745 
    return
17746 
 
17747 
 
17748 
  def __repr__(self):
17749 
    L = ['%s=%r' % (key, value)
17750 
      for key, value in self.__dict__.iteritems()]
17751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17752 
 
17753 
  def __eq__(self, other):
17754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17755 
 
17756 
  def __ne__(self, other):
17757 
    return not (self == other)
4018 chandransh 17758 
 
17759 
class getItemWiseRiskyOrdersCount_args:
17760 
 
17761 
  thrift_spec = (
17762 
  )
17763 
 
17764 
  def read(self, iprot):
17765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17767 
      return
17768 
    iprot.readStructBegin()
17769 
    while True:
17770 
      (fname, ftype, fid) = iprot.readFieldBegin()
17771 
      if ftype == TType.STOP:
17772 
        break
17773 
      else:
17774 
        iprot.skip(ftype)
17775 
      iprot.readFieldEnd()
17776 
    iprot.readStructEnd()
17777 
 
17778 
  def write(self, oprot):
17779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17781 
      return
17782 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17783 
    oprot.writeFieldStop()
17784 
    oprot.writeStructEnd()
17785 
 
17786 
  def validate(self):
17787 
    return
17788 
 
17789 
 
17790 
  def __repr__(self):
17791 
    L = ['%s=%r' % (key, value)
17792 
      for key, value in self.__dict__.iteritems()]
17793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17794 
 
17795 
  def __eq__(self, other):
17796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17797 
 
17798 
  def __ne__(self, other):
17799 
    return not (self == other)
17800 
 
17801 
class getItemWiseRiskyOrdersCount_result:
17802 
  """
17803 
  Attributes:
17804 
   - success
17805 
  """
17806 
 
17807 
  thrift_spec = (
17808 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17809 
  )
17810 
 
17811 
  def __init__(self, success=None,):
17812 
    self.success = success
17813 
 
17814 
  def read(self, iprot):
17815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17817 
      return
17818 
    iprot.readStructBegin()
17819 
    while True:
17820 
      (fname, ftype, fid) = iprot.readFieldBegin()
17821 
      if ftype == TType.STOP:
17822 
        break
17823 
      if fid == 0:
17824 
        if ftype == TType.MAP:
17825 
          self.success = {}
5386 phani.kuma 17826 
          (_ktype401, _vtype402, _size400 ) = iprot.readMapBegin()
17827 
          for _i404 in xrange(_size400):
17828 
            _key405 = iprot.readI64();
17829 
            _val406 = iprot.readI64();
17830 
            self.success[_key405] = _val406
4018 chandransh 17831 
          iprot.readMapEnd()
17832 
        else:
17833 
          iprot.skip(ftype)
17834 
      else:
17835 
        iprot.skip(ftype)
17836 
      iprot.readFieldEnd()
17837 
    iprot.readStructEnd()
17838 
 
17839 
  def write(self, oprot):
17840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17842 
      return
17843 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17844 
    if self.success is not None:
17845 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17846 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5386 phani.kuma 17847 
      for kiter407,viter408 in self.success.items():
17848 
        oprot.writeI64(kiter407)
17849 
        oprot.writeI64(viter408)
4018 chandransh 17850 
      oprot.writeMapEnd()
17851 
      oprot.writeFieldEnd()
17852 
    oprot.writeFieldStop()
17853 
    oprot.writeStructEnd()
17854 
 
17855 
  def validate(self):
17856 
    return
17857 
 
17858 
 
17859 
  def __repr__(self):
17860 
    L = ['%s=%r' % (key, value)
17861 
      for key, value in self.__dict__.iteritems()]
17862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17863 
 
17864 
  def __eq__(self, other):
17865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17866 
 
17867 
  def __ne__(self, other):
17868 
    return not (self == other)
4247 rajveer 17869 
 
4295 varun.gupt 17870 
class getOrdersForItemIds_args:
17871 
  """
17872 
  Attributes:
17873 
   - itemIds
17874 
  """
17875 
 
17876 
  thrift_spec = (
17877 
    None, # 0
17878 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17879 
  )
17880 
 
17881 
  def __init__(self, itemIds=None,):
17882 
    self.itemIds = itemIds
17883 
 
17884 
  def read(self, iprot):
17885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17887 
      return
17888 
    iprot.readStructBegin()
17889 
    while True:
17890 
      (fname, ftype, fid) = iprot.readFieldBegin()
17891 
      if ftype == TType.STOP:
17892 
        break
17893 
      if fid == 1:
17894 
        if ftype == TType.LIST:
17895 
          self.itemIds = []
5386 phani.kuma 17896 
          (_etype412, _size409) = iprot.readListBegin()
17897 
          for _i413 in xrange(_size409):
17898 
            _elem414 = iprot.readI64();
17899 
            self.itemIds.append(_elem414)
4295 varun.gupt 17900 
          iprot.readListEnd()
17901 
        else:
17902 
          iprot.skip(ftype)
17903 
      else:
17904 
        iprot.skip(ftype)
17905 
      iprot.readFieldEnd()
17906 
    iprot.readStructEnd()
17907 
 
17908 
  def write(self, oprot):
17909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17911 
      return
17912 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17913 
    if self.itemIds is not None:
17914 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17915 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5386 phani.kuma 17916 
      for iter415 in self.itemIds:
17917 
        oprot.writeI64(iter415)
4295 varun.gupt 17918 
      oprot.writeListEnd()
17919 
      oprot.writeFieldEnd()
17920 
    oprot.writeFieldStop()
17921 
    oprot.writeStructEnd()
17922 
 
17923 
  def validate(self):
17924 
    return
17925 
 
17926 
 
17927 
  def __repr__(self):
17928 
    L = ['%s=%r' % (key, value)
17929 
      for key, value in self.__dict__.iteritems()]
17930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17931 
 
17932 
  def __eq__(self, other):
17933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17934 
 
17935 
  def __ne__(self, other):
17936 
    return not (self == other)
17937 
 
17938 
class getOrdersForItemIds_result:
17939 
  """
17940 
  Attributes:
17941 
   - success
17942 
  """
17943 
 
17944 
  thrift_spec = (
17945 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17946 
  )
17947 
 
17948 
  def __init__(self, success=None,):
17949 
    self.success = success
17950 
 
17951 
  def read(self, iprot):
17952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17954 
      return
17955 
    iprot.readStructBegin()
17956 
    while True:
17957 
      (fname, ftype, fid) = iprot.readFieldBegin()
17958 
      if ftype == TType.STOP:
17959 
        break
17960 
      if fid == 0:
17961 
        if ftype == TType.LIST:
17962 
          self.success = []
5386 phani.kuma 17963 
          (_etype419, _size416) = iprot.readListBegin()
17964 
          for _i420 in xrange(_size416):
17965 
            _elem421 = Order()
17966 
            _elem421.read(iprot)
17967 
            self.success.append(_elem421)
4295 varun.gupt 17968 
          iprot.readListEnd()
17969 
        else:
17970 
          iprot.skip(ftype)
17971 
      else:
17972 
        iprot.skip(ftype)
17973 
      iprot.readFieldEnd()
17974 
    iprot.readStructEnd()
17975 
 
17976 
  def write(self, oprot):
17977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17979 
      return
17980 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17981 
    if self.success is not None:
17982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17983 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 17984 
      for iter422 in self.success:
17985 
        iter422.write(oprot)
4295 varun.gupt 17986 
      oprot.writeListEnd()
17987 
      oprot.writeFieldEnd()
17988 
    oprot.writeFieldStop()
17989 
    oprot.writeStructEnd()
17990 
 
17991 
  def validate(self):
17992 
    return
17993 
 
17994 
 
17995 
  def __repr__(self):
17996 
    L = ['%s=%r' % (key, value)
17997 
      for key, value in self.__dict__.iteritems()]
17998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17999 
 
18000 
  def __eq__(self, other):
18001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18002 
 
18003 
  def __ne__(self, other):
18004 
    return not (self == other)
18005 
 
4247 rajveer 18006 
class markOrderCancellationRequestReceived_args:
18007 
  """
18008 
  Attributes:
18009 
   - orderId
18010 
  """
18011 
 
18012 
  thrift_spec = (
18013 
    None, # 0
18014 
    (1, TType.I64, 'orderId', None, None, ), # 1
18015 
  )
18016 
 
18017 
  def __init__(self, orderId=None,):
18018 
    self.orderId = orderId
18019 
 
18020 
  def read(self, iprot):
18021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18023 
      return
18024 
    iprot.readStructBegin()
18025 
    while True:
18026 
      (fname, ftype, fid) = iprot.readFieldBegin()
18027 
      if ftype == TType.STOP:
18028 
        break
18029 
      if fid == 1:
18030 
        if ftype == TType.I64:
18031 
          self.orderId = iprot.readI64();
18032 
        else:
18033 
          iprot.skip(ftype)
18034 
      else:
18035 
        iprot.skip(ftype)
18036 
      iprot.readFieldEnd()
18037 
    iprot.readStructEnd()
18038 
 
18039 
  def write(self, oprot):
18040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18042 
      return
18043 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18044 
    if self.orderId is not None:
18045 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18046 
      oprot.writeI64(self.orderId)
18047 
      oprot.writeFieldEnd()
18048 
    oprot.writeFieldStop()
18049 
    oprot.writeStructEnd()
18050 
 
18051 
  def validate(self):
18052 
    return
18053 
 
18054 
 
18055 
  def __repr__(self):
18056 
    L = ['%s=%r' % (key, value)
18057 
      for key, value in self.__dict__.iteritems()]
18058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18059 
 
18060 
  def __eq__(self, other):
18061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18062 
 
18063 
  def __ne__(self, other):
18064 
    return not (self == other)
18065 
 
18066 
class markOrderCancellationRequestReceived_result:
18067 
  """
18068 
  Attributes:
18069 
   - ex
18070 
  """
18071 
 
18072 
  thrift_spec = (
18073 
    None, # 0
18074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18075 
  )
18076 
 
18077 
  def __init__(self, ex=None,):
18078 
    self.ex = ex
18079 
 
18080 
  def read(self, iprot):
18081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18083 
      return
18084 
    iprot.readStructBegin()
18085 
    while True:
18086 
      (fname, ftype, fid) = iprot.readFieldBegin()
18087 
      if ftype == TType.STOP:
18088 
        break
18089 
      if fid == 1:
18090 
        if ftype == TType.STRUCT:
18091 
          self.ex = TransactionServiceException()
18092 
          self.ex.read(iprot)
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      else:
18096 
        iprot.skip(ftype)
18097 
      iprot.readFieldEnd()
18098 
    iprot.readStructEnd()
18099 
 
18100 
  def write(self, oprot):
18101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18103 
      return
18104 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18105 
    if self.ex is not None:
18106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18107 
      self.ex.write(oprot)
18108 
      oprot.writeFieldEnd()
18109 
    oprot.writeFieldStop()
18110 
    oprot.writeStructEnd()
18111 
 
18112 
  def validate(self):
18113 
    return
18114 
 
18115 
 
18116 
  def __repr__(self):
18117 
    L = ['%s=%r' % (key, value)
18118 
      for key, value in self.__dict__.iteritems()]
18119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18120 
 
18121 
  def __eq__(self, other):
18122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18123 
 
18124 
  def __ne__(self, other):
18125 
    return not (self == other)
18126 
 
18127 
class markOrderCancellationRequestConfirmed_args:
18128 
  """
18129 
  Attributes:
18130 
   - orderId
18131 
  """
18132 
 
18133 
  thrift_spec = (
18134 
    None, # 0
18135 
    (1, TType.I64, 'orderId', None, None, ), # 1
18136 
  )
18137 
 
18138 
  def __init__(self, orderId=None,):
18139 
    self.orderId = orderId
18140 
 
18141 
  def read(self, iprot):
18142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18144 
      return
18145 
    iprot.readStructBegin()
18146 
    while True:
18147 
      (fname, ftype, fid) = iprot.readFieldBegin()
18148 
      if ftype == TType.STOP:
18149 
        break
18150 
      if fid == 1:
18151 
        if ftype == TType.I64:
18152 
          self.orderId = iprot.readI64();
18153 
        else:
18154 
          iprot.skip(ftype)
18155 
      else:
18156 
        iprot.skip(ftype)
18157 
      iprot.readFieldEnd()
18158 
    iprot.readStructEnd()
18159 
 
18160 
  def write(self, oprot):
18161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18163 
      return
18164 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18165 
    if self.orderId is not None:
18166 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18167 
      oprot.writeI64(self.orderId)
18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
18186 
 
18187 
class markOrderCancellationRequestConfirmed_result:
18188 
  """
18189 
  Attributes:
18190 
   - ex
18191 
  """
18192 
 
18193 
  thrift_spec = (
18194 
    None, # 0
18195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18196 
  )
18197 
 
18198 
  def __init__(self, ex=None,):
18199 
    self.ex = ex
18200 
 
18201 
  def read(self, iprot):
18202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18204 
      return
18205 
    iprot.readStructBegin()
18206 
    while True:
18207 
      (fname, ftype, fid) = iprot.readFieldBegin()
18208 
      if ftype == TType.STOP:
18209 
        break
18210 
      if fid == 1:
18211 
        if ftype == TType.STRUCT:
18212 
          self.ex = TransactionServiceException()
18213 
          self.ex.read(iprot)
18214 
        else:
18215 
          iprot.skip(ftype)
18216 
      else:
18217 
        iprot.skip(ftype)
18218 
      iprot.readFieldEnd()
18219 
    iprot.readStructEnd()
18220 
 
18221 
  def write(self, oprot):
18222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18224 
      return
18225 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18226 
    if self.ex is not None:
18227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18228 
      self.ex.write(oprot)
18229 
      oprot.writeFieldEnd()
18230 
    oprot.writeFieldStop()
18231 
    oprot.writeStructEnd()
18232 
 
18233 
  def validate(self):
18234 
    return
18235 
 
18236 
 
18237 
  def __repr__(self):
18238 
    L = ['%s=%r' % (key, value)
18239 
      for key, value in self.__dict__.iteritems()]
18240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18241 
 
18242 
  def __eq__(self, other):
18243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18244 
 
18245 
  def __ne__(self, other):
18246 
    return not (self == other)
18247 
 
18248 
class markOrderCancellationRequestDenied_args:
18249 
  """
18250 
  Attributes:
18251 
   - orderId
18252 
  """
18253 
 
18254 
  thrift_spec = (
18255 
    None, # 0
18256 
    (1, TType.I64, 'orderId', None, None, ), # 1
18257 
  )
18258 
 
18259 
  def __init__(self, orderId=None,):
18260 
    self.orderId = orderId
18261 
 
18262 
  def read(self, iprot):
18263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18265 
      return
18266 
    iprot.readStructBegin()
18267 
    while True:
18268 
      (fname, ftype, fid) = iprot.readFieldBegin()
18269 
      if ftype == TType.STOP:
18270 
        break
18271 
      if fid == 1:
18272 
        if ftype == TType.I64:
18273 
          self.orderId = iprot.readI64();
18274 
        else:
18275 
          iprot.skip(ftype)
18276 
      else:
18277 
        iprot.skip(ftype)
18278 
      iprot.readFieldEnd()
18279 
    iprot.readStructEnd()
18280 
 
18281 
  def write(self, oprot):
18282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18284 
      return
18285 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18286 
    if self.orderId is not None:
18287 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18288 
      oprot.writeI64(self.orderId)
18289 
      oprot.writeFieldEnd()
18290 
    oprot.writeFieldStop()
18291 
    oprot.writeStructEnd()
18292 
 
18293 
  def validate(self):
18294 
    return
18295 
 
18296 
 
18297 
  def __repr__(self):
18298 
    L = ['%s=%r' % (key, value)
18299 
      for key, value in self.__dict__.iteritems()]
18300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18301 
 
18302 
  def __eq__(self, other):
18303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18304 
 
18305 
  def __ne__(self, other):
18306 
    return not (self == other)
18307 
 
18308 
class markOrderCancellationRequestDenied_result:
18309 
  """
18310 
  Attributes:
18311 
   - ex
18312 
  """
18313 
 
18314 
  thrift_spec = (
18315 
    None, # 0
18316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18317 
  )
18318 
 
18319 
  def __init__(self, ex=None,):
18320 
    self.ex = ex
18321 
 
18322 
  def read(self, iprot):
18323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18325 
      return
18326 
    iprot.readStructBegin()
18327 
    while True:
18328 
      (fname, ftype, fid) = iprot.readFieldBegin()
18329 
      if ftype == TType.STOP:
18330 
        break
18331 
      if fid == 1:
18332 
        if ftype == TType.STRUCT:
18333 
          self.ex = TransactionServiceException()
18334 
          self.ex.read(iprot)
18335 
        else:
18336 
          iprot.skip(ftype)
18337 
      else:
18338 
        iprot.skip(ftype)
18339 
      iprot.readFieldEnd()
18340 
    iprot.readStructEnd()
18341 
 
18342 
  def write(self, oprot):
18343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18345 
      return
18346 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18347 
    if self.ex is not None:
18348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18349 
      self.ex.write(oprot)
18350 
      oprot.writeFieldEnd()
18351 
    oprot.writeFieldStop()
18352 
    oprot.writeStructEnd()
18353 
 
18354 
  def validate(self):
18355 
    return
18356 
 
18357 
 
18358 
  def __repr__(self):
18359 
    L = ['%s=%r' % (key, value)
18360 
      for key, value in self.__dict__.iteritems()]
18361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18362 
 
18363 
  def __eq__(self, other):
18364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18365 
 
18366 
  def __ne__(self, other):
18367 
    return not (self == other)
18368 
 
4258 rajveer 18369 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18370 
  """
18371 
  Attributes:
4258 rajveer 18372 
   - transactionId
4247 rajveer 18373 
  """
18374 
 
18375 
  thrift_spec = (
18376 
    None, # 0
4258 rajveer 18377 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18378 
  )
18379 
 
4258 rajveer 18380 
  def __init__(self, transactionId=None,):
18381 
    self.transactionId = transactionId
4247 rajveer 18382 
 
18383 
  def read(self, iprot):
18384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18386 
      return
18387 
    iprot.readStructBegin()
18388 
    while True:
18389 
      (fname, ftype, fid) = iprot.readFieldBegin()
18390 
      if ftype == TType.STOP:
18391 
        break
18392 
      if fid == 1:
18393 
        if ftype == TType.I64:
4258 rajveer 18394 
          self.transactionId = iprot.readI64();
4247 rajveer 18395 
        else:
18396 
          iprot.skip(ftype)
18397 
      else:
18398 
        iprot.skip(ftype)
18399 
      iprot.readFieldEnd()
18400 
    iprot.readStructEnd()
18401 
 
18402 
  def write(self, oprot):
18403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18405 
      return
4258 rajveer 18406 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18407 
    if self.transactionId is not None:
18408 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18409 
      oprot.writeI64(self.transactionId)
4247 rajveer 18410 
      oprot.writeFieldEnd()
18411 
    oprot.writeFieldStop()
18412 
    oprot.writeStructEnd()
18413 
 
18414 
  def validate(self):
18415 
    return
18416 
 
18417 
 
18418 
  def __repr__(self):
18419 
    L = ['%s=%r' % (key, value)
18420 
      for key, value in self.__dict__.iteritems()]
18421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18422 
 
18423 
  def __eq__(self, other):
18424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18425 
 
18426 
  def __ne__(self, other):
18427 
    return not (self == other)
18428 
 
4258 rajveer 18429 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18430 
  """
18431 
  Attributes:
18432 
   - ex
18433 
  """
18434 
 
18435 
  thrift_spec = (
18436 
    None, # 0
18437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18438 
  )
18439 
 
18440 
  def __init__(self, ex=None,):
18441 
    self.ex = ex
18442 
 
18443 
  def read(self, iprot):
18444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18446 
      return
18447 
    iprot.readStructBegin()
18448 
    while True:
18449 
      (fname, ftype, fid) = iprot.readFieldBegin()
18450 
      if ftype == TType.STOP:
18451 
        break
18452 
      if fid == 1:
18453 
        if ftype == TType.STRUCT:
18454 
          self.ex = TransactionServiceException()
18455 
          self.ex.read(iprot)
18456 
        else:
18457 
          iprot.skip(ftype)
18458 
      else:
18459 
        iprot.skip(ftype)
18460 
      iprot.readFieldEnd()
18461 
    iprot.readStructEnd()
18462 
 
18463 
  def write(self, oprot):
18464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18466 
      return
4258 rajveer 18467 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18468 
    if self.ex is not None:
18469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18470 
      self.ex.write(oprot)
18471 
      oprot.writeFieldEnd()
18472 
    oprot.writeFieldStop()
18473 
    oprot.writeStructEnd()
18474 
 
18475 
  def validate(self):
18476 
    return
18477 
 
18478 
 
18479 
  def __repr__(self):
18480 
    L = ['%s=%r' % (key, value)
18481 
      for key, value in self.__dict__.iteritems()]
18482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18483 
 
18484 
  def __eq__(self, other):
18485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18486 
 
18487 
  def __ne__(self, other):
18488 
    return not (self == other)
4259 anupam.sin 18489 
 
18490 
class refundTransaction_args:
18491 
  """
18492 
  Attributes:
18493 
   - transactionId
18494 
   - refundedBy
18495 
   - reason
18496 
  """
18497 
 
18498 
  thrift_spec = (
18499 
    None, # 0
18500 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18501 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18502 
    (3, TType.STRING, 'reason', None, None, ), # 3
18503 
  )
18504 
 
18505 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18506 
    self.transactionId = transactionId
18507 
    self.refundedBy = refundedBy
18508 
    self.reason = reason
18509 
 
18510 
  def read(self, iprot):
18511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18513 
      return
18514 
    iprot.readStructBegin()
18515 
    while True:
18516 
      (fname, ftype, fid) = iprot.readFieldBegin()
18517 
      if ftype == TType.STOP:
18518 
        break
18519 
      if fid == 1:
18520 
        if ftype == TType.I64:
18521 
          self.transactionId = iprot.readI64();
18522 
        else:
18523 
          iprot.skip(ftype)
18524 
      elif fid == 2:
18525 
        if ftype == TType.STRING:
18526 
          self.refundedBy = iprot.readString();
18527 
        else:
18528 
          iprot.skip(ftype)
18529 
      elif fid == 3:
18530 
        if ftype == TType.STRING:
18531 
          self.reason = iprot.readString();
18532 
        else:
18533 
          iprot.skip(ftype)
18534 
      else:
18535 
        iprot.skip(ftype)
18536 
      iprot.readFieldEnd()
18537 
    iprot.readStructEnd()
18538 
 
18539 
  def write(self, oprot):
18540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18542 
      return
18543 
    oprot.writeStructBegin('refundTransaction_args')
18544 
    if self.transactionId is not None:
18545 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18546 
      oprot.writeI64(self.transactionId)
18547 
      oprot.writeFieldEnd()
18548 
    if self.refundedBy is not None:
18549 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18550 
      oprot.writeString(self.refundedBy)
18551 
      oprot.writeFieldEnd()
18552 
    if self.reason is not None:
18553 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18554 
      oprot.writeString(self.reason)
18555 
      oprot.writeFieldEnd()
18556 
    oprot.writeFieldStop()
18557 
    oprot.writeStructEnd()
18558 
 
18559 
  def validate(self):
18560 
    return
18561 
 
18562 
 
18563 
  def __repr__(self):
18564 
    L = ['%s=%r' % (key, value)
18565 
      for key, value in self.__dict__.iteritems()]
18566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18567 
 
18568 
  def __eq__(self, other):
18569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18570 
 
18571 
  def __ne__(self, other):
18572 
    return not (self == other)
18573 
 
18574 
class refundTransaction_result:
18575 
  """
18576 
  Attributes:
18577 
   - ex
18578 
  """
18579 
 
18580 
  thrift_spec = (
18581 
    None, # 0
18582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18583 
  )
18584 
 
18585 
  def __init__(self, ex=None,):
18586 
    self.ex = ex
18587 
 
18588 
  def read(self, iprot):
18589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18591 
      return
18592 
    iprot.readStructBegin()
18593 
    while True:
18594 
      (fname, ftype, fid) = iprot.readFieldBegin()
18595 
      if ftype == TType.STOP:
18596 
        break
18597 
      if fid == 1:
18598 
        if ftype == TType.STRUCT:
18599 
          self.ex = TransactionServiceException()
18600 
          self.ex.read(iprot)
18601 
        else:
18602 
          iprot.skip(ftype)
18603 
      else:
18604 
        iprot.skip(ftype)
18605 
      iprot.readFieldEnd()
18606 
    iprot.readStructEnd()
18607 
 
18608 
  def write(self, oprot):
18609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18611 
      return
18612 
    oprot.writeStructBegin('refundTransaction_result')
18613 
    if self.ex is not None:
18614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18615 
      self.ex.write(oprot)
18616 
      oprot.writeFieldEnd()
18617 
    oprot.writeFieldStop()
18618 
    oprot.writeStructEnd()
18619 
 
18620 
  def validate(self):
18621 
    return
18622 
 
18623 
 
18624 
  def __repr__(self):
18625 
    L = ['%s=%r' % (key, value)
18626 
      for key, value in self.__dict__.iteritems()]
18627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18628 
 
18629 
  def __eq__(self, other):
18630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18631 
 
18632 
  def __ne__(self, other):
18633 
    return not (self == other)
4285 rajveer 18634 
 
4324 mandeep.dh 18635 
class updateShipmentAddress_args:
18636 
  """
18637 
  Attributes:
18638 
   - orderId
18639 
   - addressId
18640 
  """
18641 
 
18642 
  thrift_spec = (
18643 
    None, # 0
18644 
    (1, TType.I64, 'orderId', None, None, ), # 1
18645 
    (2, TType.I64, 'addressId', None, None, ), # 2
18646 
  )
18647 
 
18648 
  def __init__(self, orderId=None, addressId=None,):
18649 
    self.orderId = orderId
18650 
    self.addressId = addressId
18651 
 
18652 
  def read(self, iprot):
18653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18655 
      return
18656 
    iprot.readStructBegin()
18657 
    while True:
18658 
      (fname, ftype, fid) = iprot.readFieldBegin()
18659 
      if ftype == TType.STOP:
18660 
        break
18661 
      if fid == 1:
18662 
        if ftype == TType.I64:
18663 
          self.orderId = iprot.readI64();
18664 
        else:
18665 
          iprot.skip(ftype)
18666 
      elif fid == 2:
18667 
        if ftype == TType.I64:
18668 
          self.addressId = iprot.readI64();
18669 
        else:
18670 
          iprot.skip(ftype)
18671 
      else:
18672 
        iprot.skip(ftype)
18673 
      iprot.readFieldEnd()
18674 
    iprot.readStructEnd()
18675 
 
18676 
  def write(self, oprot):
18677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18679 
      return
18680 
    oprot.writeStructBegin('updateShipmentAddress_args')
18681 
    if self.orderId is not None:
18682 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18683 
      oprot.writeI64(self.orderId)
18684 
      oprot.writeFieldEnd()
18685 
    if self.addressId is not None:
18686 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18687 
      oprot.writeI64(self.addressId)
18688 
      oprot.writeFieldEnd()
18689 
    oprot.writeFieldStop()
18690 
    oprot.writeStructEnd()
18691 
 
18692 
  def validate(self):
18693 
    return
18694 
 
18695 
 
18696 
  def __repr__(self):
18697 
    L = ['%s=%r' % (key, value)
18698 
      for key, value in self.__dict__.iteritems()]
18699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18700 
 
18701 
  def __eq__(self, other):
18702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18703 
 
18704 
  def __ne__(self, other):
18705 
    return not (self == other)
18706 
 
18707 
class updateShipmentAddress_result:
18708 
  """
18709 
  Attributes:
18710 
   - ex
18711 
  """
18712 
 
18713 
  thrift_spec = (
18714 
    None, # 0
18715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18716 
  )
18717 
 
18718 
  def __init__(self, ex=None,):
18719 
    self.ex = ex
18720 
 
18721 
  def read(self, iprot):
18722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18724 
      return
18725 
    iprot.readStructBegin()
18726 
    while True:
18727 
      (fname, ftype, fid) = iprot.readFieldBegin()
18728 
      if ftype == TType.STOP:
18729 
        break
18730 
      if fid == 1:
18731 
        if ftype == TType.STRUCT:
18732 
          self.ex = TransactionServiceException()
18733 
          self.ex.read(iprot)
18734 
        else:
18735 
          iprot.skip(ftype)
18736 
      else:
18737 
        iprot.skip(ftype)
18738 
      iprot.readFieldEnd()
18739 
    iprot.readStructEnd()
18740 
 
18741 
  def write(self, oprot):
18742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18744 
      return
18745 
    oprot.writeStructBegin('updateShipmentAddress_result')
18746 
    if self.ex is not None:
18747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18748 
      self.ex.write(oprot)
18749 
      oprot.writeFieldEnd()
18750 
    oprot.writeFieldStop()
18751 
    oprot.writeStructEnd()
18752 
 
18753 
  def validate(self):
18754 
    return
18755 
 
18756 
 
18757 
  def __repr__(self):
18758 
    L = ['%s=%r' % (key, value)
18759 
      for key, value in self.__dict__.iteritems()]
18760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18761 
 
18762 
  def __eq__(self, other):
18763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18764 
 
18765 
  def __ne__(self, other):
18766 
    return not (self == other)
18767 
 
4285 rajveer 18768 
class acceptOrdersForItemId_args:
18769 
  """
18770 
  Attributes:
18771 
   - itemId
18772 
   - inventory
18773 
  """
18774 
 
18775 
  thrift_spec = (
18776 
    None, # 0
18777 
    (1, TType.I64, 'itemId', None, None, ), # 1
18778 
    (2, TType.I64, 'inventory', None, None, ), # 2
18779 
  )
18780 
 
18781 
  def __init__(self, itemId=None, inventory=None,):
18782 
    self.itemId = itemId
18783 
    self.inventory = inventory
18784 
 
18785 
  def read(self, iprot):
18786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18788 
      return
18789 
    iprot.readStructBegin()
18790 
    while True:
18791 
      (fname, ftype, fid) = iprot.readFieldBegin()
18792 
      if ftype == TType.STOP:
18793 
        break
18794 
      if fid == 1:
18795 
        if ftype == TType.I64:
18796 
          self.itemId = iprot.readI64();
18797 
        else:
18798 
          iprot.skip(ftype)
18799 
      elif fid == 2:
18800 
        if ftype == TType.I64:
18801 
          self.inventory = iprot.readI64();
18802 
        else:
18803 
          iprot.skip(ftype)
18804 
      else:
18805 
        iprot.skip(ftype)
18806 
      iprot.readFieldEnd()
18807 
    iprot.readStructEnd()
18808 
 
18809 
  def write(self, oprot):
18810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18812 
      return
18813 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18814 
    if self.itemId is not None:
18815 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18816 
      oprot.writeI64(self.itemId)
18817 
      oprot.writeFieldEnd()
18818 
    if self.inventory is not None:
18819 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18820 
      oprot.writeI64(self.inventory)
18821 
      oprot.writeFieldEnd()
18822 
    oprot.writeFieldStop()
18823 
    oprot.writeStructEnd()
18824 
 
18825 
  def validate(self):
18826 
    return
18827 
 
18828 
 
18829 
  def __repr__(self):
18830 
    L = ['%s=%r' % (key, value)
18831 
      for key, value in self.__dict__.iteritems()]
18832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18833 
 
18834 
  def __eq__(self, other):
18835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18836 
 
18837 
  def __ne__(self, other):
18838 
    return not (self == other)
18839 
 
18840 
class acceptOrdersForItemId_result:
18841 
  """
18842 
  Attributes:
18843 
   - success
18844 
   - ex
18845 
  """
18846 
 
18847 
  thrift_spec = (
18848 
    (0, TType.BOOL, 'success', None, None, ), # 0
18849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18850 
  )
18851 
 
18852 
  def __init__(self, success=None, ex=None,):
18853 
    self.success = success
18854 
    self.ex = ex
18855 
 
18856 
  def read(self, iprot):
18857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18859 
      return
18860 
    iprot.readStructBegin()
18861 
    while True:
18862 
      (fname, ftype, fid) = iprot.readFieldBegin()
18863 
      if ftype == TType.STOP:
18864 
        break
18865 
      if fid == 0:
18866 
        if ftype == TType.BOOL:
18867 
          self.success = iprot.readBool();
18868 
        else:
18869 
          iprot.skip(ftype)
18870 
      elif fid == 1:
18871 
        if ftype == TType.STRUCT:
18872 
          self.ex = TransactionServiceException()
18873 
          self.ex.read(iprot)
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      else:
18877 
        iprot.skip(ftype)
18878 
      iprot.readFieldEnd()
18879 
    iprot.readStructEnd()
18880 
 
18881 
  def write(self, oprot):
18882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18884 
      return
18885 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18886 
    if self.success is not None:
18887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18888 
      oprot.writeBool(self.success)
18889 
      oprot.writeFieldEnd()
18890 
    if self.ex is not None:
18891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18892 
      self.ex.write(oprot)
18893 
      oprot.writeFieldEnd()
18894 
    oprot.writeFieldStop()
18895 
    oprot.writeStructEnd()
18896 
 
18897 
  def validate(self):
18898 
    return
18899 
 
18900 
 
18901 
  def __repr__(self):
18902 
    L = ['%s=%r' % (key, value)
18903 
      for key, value in self.__dict__.iteritems()]
18904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18905 
 
18906 
  def __eq__(self, other):
18907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18908 
 
18909 
  def __ne__(self, other):
18910 
    return not (self == other)
4303 rajveer 18911 
 
18912 
class markOrdersAsPORaised_args:
18913 
  """
18914 
  Attributes:
18915 
   - vendorId
18916 
   - itemId
18917 
   - quantity
18918 
   - estimate
4369 rajveer 18919 
   - isReminder
4303 rajveer 18920 
  """
18921 
 
18922 
  thrift_spec = (
18923 
    None, # 0
18924 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18925 
    (2, TType.I64, 'itemId', None, None, ), # 2
18926 
    (3, TType.I64, 'quantity', None, None, ), # 3
18927 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18928 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18929 
  )
18930 
 
4369 rajveer 18931 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18932 
    self.vendorId = vendorId
18933 
    self.itemId = itemId
18934 
    self.quantity = quantity
18935 
    self.estimate = estimate
4369 rajveer 18936 
    self.isReminder = isReminder
4303 rajveer 18937 
 
18938 
  def read(self, iprot):
18939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18941 
      return
18942 
    iprot.readStructBegin()
18943 
    while True:
18944 
      (fname, ftype, fid) = iprot.readFieldBegin()
18945 
      if ftype == TType.STOP:
18946 
        break
18947 
      if fid == 1:
18948 
        if ftype == TType.I64:
18949 
          self.vendorId = iprot.readI64();
18950 
        else:
18951 
          iprot.skip(ftype)
18952 
      elif fid == 2:
18953 
        if ftype == TType.I64:
18954 
          self.itemId = iprot.readI64();
18955 
        else:
18956 
          iprot.skip(ftype)
18957 
      elif fid == 3:
18958 
        if ftype == TType.I64:
18959 
          self.quantity = iprot.readI64();
18960 
        else:
18961 
          iprot.skip(ftype)
18962 
      elif fid == 4:
18963 
        if ftype == TType.I64:
18964 
          self.estimate = iprot.readI64();
18965 
        else:
18966 
          iprot.skip(ftype)
4369 rajveer 18967 
      elif fid == 5:
18968 
        if ftype == TType.BOOL:
18969 
          self.isReminder = iprot.readBool();
18970 
        else:
18971 
          iprot.skip(ftype)
4303 rajveer 18972 
      else:
18973 
        iprot.skip(ftype)
18974 
      iprot.readFieldEnd()
18975 
    iprot.readStructEnd()
18976 
 
18977 
  def write(self, oprot):
18978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18980 
      return
18981 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18982 
    if self.vendorId is not None:
18983 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18984 
      oprot.writeI64(self.vendorId)
18985 
      oprot.writeFieldEnd()
18986 
    if self.itemId is not None:
18987 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18988 
      oprot.writeI64(self.itemId)
18989 
      oprot.writeFieldEnd()
18990 
    if self.quantity is not None:
18991 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18992 
      oprot.writeI64(self.quantity)
18993 
      oprot.writeFieldEnd()
18994 
    if self.estimate is not None:
18995 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18996 
      oprot.writeI64(self.estimate)
18997 
      oprot.writeFieldEnd()
4369 rajveer 18998 
    if self.isReminder is not None:
18999 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19000 
      oprot.writeBool(self.isReminder)
19001 
      oprot.writeFieldEnd()
4303 rajveer 19002 
    oprot.writeFieldStop()
19003 
    oprot.writeStructEnd()
19004 
 
19005 
  def validate(self):
19006 
    return
19007 
 
19008 
 
19009 
  def __repr__(self):
19010 
    L = ['%s=%r' % (key, value)
19011 
      for key, value in self.__dict__.iteritems()]
19012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19013 
 
19014 
  def __eq__(self, other):
19015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19016 
 
19017 
  def __ne__(self, other):
19018 
    return not (self == other)
19019 
 
19020 
class markOrdersAsPORaised_result:
19021 
  """
19022 
  Attributes:
19023 
   - ex
19024 
  """
19025 
 
19026 
  thrift_spec = (
19027 
    None, # 0
19028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19029 
  )
19030 
 
19031 
  def __init__(self, ex=None,):
19032 
    self.ex = ex
19033 
 
19034 
  def read(self, iprot):
19035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19037 
      return
19038 
    iprot.readStructBegin()
19039 
    while True:
19040 
      (fname, ftype, fid) = iprot.readFieldBegin()
19041 
      if ftype == TType.STOP:
19042 
        break
19043 
      if fid == 1:
19044 
        if ftype == TType.STRUCT:
19045 
          self.ex = TransactionServiceException()
19046 
          self.ex.read(iprot)
19047 
        else:
19048 
          iprot.skip(ftype)
19049 
      else:
19050 
        iprot.skip(ftype)
19051 
      iprot.readFieldEnd()
19052 
    iprot.readStructEnd()
19053 
 
19054 
  def write(self, oprot):
19055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19057 
      return
19058 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19059 
    if self.ex is not None:
19060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19061 
      self.ex.write(oprot)
19062 
      oprot.writeFieldEnd()
19063 
    oprot.writeFieldStop()
19064 
    oprot.writeStructEnd()
19065 
 
19066 
  def validate(self):
19067 
    return
19068 
 
19069 
 
19070 
  def __repr__(self):
19071 
    L = ['%s=%r' % (key, value)
19072 
      for key, value in self.__dict__.iteritems()]
19073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19074 
 
19075 
  def __eq__(self, other):
19076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19077 
 
19078 
  def __ne__(self, other):
19079 
    return not (self == other)
19080 
 
19081 
class markOrdersAsReversalInitiated_args:
19082 
  """
19083 
  Attributes:
19084 
   - vendorId
19085 
   - itemId
19086 
   - quantity
19087 
   - estimate
4369 rajveer 19088 
   - isReminder
4303 rajveer 19089 
  """
19090 
 
19091 
  thrift_spec = (
19092 
    None, # 0
19093 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19094 
    (2, TType.I64, 'itemId', None, None, ), # 2
19095 
    (3, TType.I64, 'quantity', None, None, ), # 3
19096 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19097 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19098 
  )
19099 
 
4369 rajveer 19100 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19101 
    self.vendorId = vendorId
19102 
    self.itemId = itemId
19103 
    self.quantity = quantity
19104 
    self.estimate = estimate
4369 rajveer 19105 
    self.isReminder = isReminder
4303 rajveer 19106 
 
19107 
  def read(self, iprot):
19108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19110 
      return
19111 
    iprot.readStructBegin()
19112 
    while True:
19113 
      (fname, ftype, fid) = iprot.readFieldBegin()
19114 
      if ftype == TType.STOP:
19115 
        break
19116 
      if fid == 1:
19117 
        if ftype == TType.I64:
19118 
          self.vendorId = iprot.readI64();
19119 
        else:
19120 
          iprot.skip(ftype)
19121 
      elif fid == 2:
19122 
        if ftype == TType.I64:
19123 
          self.itemId = iprot.readI64();
19124 
        else:
19125 
          iprot.skip(ftype)
19126 
      elif fid == 3:
19127 
        if ftype == TType.I64:
19128 
          self.quantity = iprot.readI64();
19129 
        else:
19130 
          iprot.skip(ftype)
19131 
      elif fid == 4:
19132 
        if ftype == TType.I64:
19133 
          self.estimate = iprot.readI64();
19134 
        else:
19135 
          iprot.skip(ftype)
4369 rajveer 19136 
      elif fid == 5:
19137 
        if ftype == TType.BOOL:
19138 
          self.isReminder = iprot.readBool();
19139 
        else:
19140 
          iprot.skip(ftype)
4303 rajveer 19141 
      else:
19142 
        iprot.skip(ftype)
19143 
      iprot.readFieldEnd()
19144 
    iprot.readStructEnd()
19145 
 
19146 
  def write(self, oprot):
19147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19149 
      return
19150 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19151 
    if self.vendorId is not None:
19152 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19153 
      oprot.writeI64(self.vendorId)
19154 
      oprot.writeFieldEnd()
19155 
    if self.itemId is not None:
19156 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19157 
      oprot.writeI64(self.itemId)
19158 
      oprot.writeFieldEnd()
19159 
    if self.quantity is not None:
19160 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19161 
      oprot.writeI64(self.quantity)
19162 
      oprot.writeFieldEnd()
19163 
    if self.estimate is not None:
19164 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19165 
      oprot.writeI64(self.estimate)
19166 
      oprot.writeFieldEnd()
4369 rajveer 19167 
    if self.isReminder is not None:
19168 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19169 
      oprot.writeBool(self.isReminder)
19170 
      oprot.writeFieldEnd()
4303 rajveer 19171 
    oprot.writeFieldStop()
19172 
    oprot.writeStructEnd()
19173 
 
19174 
  def validate(self):
19175 
    return
19176 
 
19177 
 
19178 
  def __repr__(self):
19179 
    L = ['%s=%r' % (key, value)
19180 
      for key, value in self.__dict__.iteritems()]
19181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19182 
 
19183 
  def __eq__(self, other):
19184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19185 
 
19186 
  def __ne__(self, other):
19187 
    return not (self == other)
19188 
 
19189 
class markOrdersAsReversalInitiated_result:
19190 
  """
19191 
  Attributes:
19192 
   - ex
19193 
  """
19194 
 
19195 
  thrift_spec = (
19196 
    None, # 0
19197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19198 
  )
19199 
 
19200 
  def __init__(self, ex=None,):
19201 
    self.ex = ex
19202 
 
19203 
  def read(self, iprot):
19204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19206 
      return
19207 
    iprot.readStructBegin()
19208 
    while True:
19209 
      (fname, ftype, fid) = iprot.readFieldBegin()
19210 
      if ftype == TType.STOP:
19211 
        break
19212 
      if fid == 1:
19213 
        if ftype == TType.STRUCT:
19214 
          self.ex = TransactionServiceException()
19215 
          self.ex.read(iprot)
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      else:
19219 
        iprot.skip(ftype)
19220 
      iprot.readFieldEnd()
19221 
    iprot.readStructEnd()
19222 
 
19223 
  def write(self, oprot):
19224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19226 
      return
19227 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19228 
    if self.ex is not None:
19229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19230 
      self.ex.write(oprot)
19231 
      oprot.writeFieldEnd()
19232 
    oprot.writeFieldStop()
19233 
    oprot.writeStructEnd()
19234 
 
19235 
  def validate(self):
19236 
    return
19237 
 
19238 
 
19239 
  def __repr__(self):
19240 
    L = ['%s=%r' % (key, value)
19241 
      for key, value in self.__dict__.iteritems()]
19242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19243 
 
19244 
  def __eq__(self, other):
19245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19246 
 
19247 
  def __ne__(self, other):
19248 
    return not (self == other)
19249 
 
19250 
class markOrdersAsNotAvailabke_args:
19251 
  """
19252 
  Attributes:
19253 
   - vendorId
19254 
   - itemId
19255 
   - quantity
19256 
   - estimate
4369 rajveer 19257 
   - isReminder
4303 rajveer 19258 
  """
19259 
 
19260 
  thrift_spec = (
19261 
    None, # 0
19262 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19263 
    (2, TType.I64, 'itemId', None, None, ), # 2
19264 
    (3, TType.I64, 'quantity', None, None, ), # 3
19265 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19266 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19267 
  )
19268 
 
4369 rajveer 19269 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19270 
    self.vendorId = vendorId
19271 
    self.itemId = itemId
19272 
    self.quantity = quantity
19273 
    self.estimate = estimate
4369 rajveer 19274 
    self.isReminder = isReminder
4303 rajveer 19275 
 
19276 
  def read(self, iprot):
19277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19279 
      return
19280 
    iprot.readStructBegin()
19281 
    while True:
19282 
      (fname, ftype, fid) = iprot.readFieldBegin()
19283 
      if ftype == TType.STOP:
19284 
        break
19285 
      if fid == 1:
19286 
        if ftype == TType.I64:
19287 
          self.vendorId = iprot.readI64();
19288 
        else:
19289 
          iprot.skip(ftype)
19290 
      elif fid == 2:
19291 
        if ftype == TType.I64:
19292 
          self.itemId = iprot.readI64();
19293 
        else:
19294 
          iprot.skip(ftype)
19295 
      elif fid == 3:
19296 
        if ftype == TType.I64:
19297 
          self.quantity = iprot.readI64();
19298 
        else:
19299 
          iprot.skip(ftype)
19300 
      elif fid == 4:
19301 
        if ftype == TType.I64:
19302 
          self.estimate = iprot.readI64();
19303 
        else:
19304 
          iprot.skip(ftype)
4369 rajveer 19305 
      elif fid == 5:
19306 
        if ftype == TType.BOOL:
19307 
          self.isReminder = iprot.readBool();
19308 
        else:
19309 
          iprot.skip(ftype)
4303 rajveer 19310 
      else:
19311 
        iprot.skip(ftype)
19312 
      iprot.readFieldEnd()
19313 
    iprot.readStructEnd()
19314 
 
19315 
  def write(self, oprot):
19316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19318 
      return
19319 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19320 
    if self.vendorId is not None:
19321 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19322 
      oprot.writeI64(self.vendorId)
19323 
      oprot.writeFieldEnd()
19324 
    if self.itemId is not None:
19325 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19326 
      oprot.writeI64(self.itemId)
19327 
      oprot.writeFieldEnd()
19328 
    if self.quantity is not None:
19329 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19330 
      oprot.writeI64(self.quantity)
19331 
      oprot.writeFieldEnd()
19332 
    if self.estimate is not None:
19333 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19334 
      oprot.writeI64(self.estimate)
19335 
      oprot.writeFieldEnd()
4369 rajveer 19336 
    if self.isReminder is not None:
19337 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19338 
      oprot.writeBool(self.isReminder)
19339 
      oprot.writeFieldEnd()
4303 rajveer 19340 
    oprot.writeFieldStop()
19341 
    oprot.writeStructEnd()
19342 
 
19343 
  def validate(self):
19344 
    return
19345 
 
19346 
 
19347 
  def __repr__(self):
19348 
    L = ['%s=%r' % (key, value)
19349 
      for key, value in self.__dict__.iteritems()]
19350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19351 
 
19352 
  def __eq__(self, other):
19353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19354 
 
19355 
  def __ne__(self, other):
19356 
    return not (self == other)
19357 
 
19358 
class markOrdersAsNotAvailabke_result:
19359 
  """
19360 
  Attributes:
19361 
   - ex
19362 
  """
19363 
 
19364 
  thrift_spec = (
19365 
    None, # 0
19366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19367 
  )
19368 
 
19369 
  def __init__(self, ex=None,):
19370 
    self.ex = ex
19371 
 
19372 
  def read(self, iprot):
19373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19375 
      return
19376 
    iprot.readStructBegin()
19377 
    while True:
19378 
      (fname, ftype, fid) = iprot.readFieldBegin()
19379 
      if ftype == TType.STOP:
19380 
        break
19381 
      if fid == 1:
19382 
        if ftype == TType.STRUCT:
19383 
          self.ex = TransactionServiceException()
19384 
          self.ex.read(iprot)
19385 
        else:
19386 
          iprot.skip(ftype)
19387 
      else:
19388 
        iprot.skip(ftype)
19389 
      iprot.readFieldEnd()
19390 
    iprot.readStructEnd()
19391 
 
19392 
  def write(self, oprot):
19393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19395 
      return
19396 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19397 
    if self.ex is not None:
19398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19399 
      self.ex.write(oprot)
19400 
      oprot.writeFieldEnd()
19401 
    oprot.writeFieldStop()
19402 
    oprot.writeStructEnd()
19403 
 
19404 
  def validate(self):
19405 
    return
19406 
 
19407 
 
19408 
  def __repr__(self):
19409 
    L = ['%s=%r' % (key, value)
19410 
      for key, value in self.__dict__.iteritems()]
19411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19412 
 
19413 
  def __eq__(self, other):
19414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19415 
 
19416 
  def __ne__(self, other):
19417 
    return not (self == other)
4369 rajveer 19418 
 
19419 
class markOrdersAsTimeout_args:
19420 
  """
19421 
  Attributes:
19422 
   - vendorId
19423 
  """
19424 
 
19425 
  thrift_spec = (
19426 
    None, # 0
19427 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19428 
  )
19429 
 
19430 
  def __init__(self, vendorId=None,):
19431 
    self.vendorId = vendorId
19432 
 
19433 
  def read(self, iprot):
19434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19436 
      return
19437 
    iprot.readStructBegin()
19438 
    while True:
19439 
      (fname, ftype, fid) = iprot.readFieldBegin()
19440 
      if ftype == TType.STOP:
19441 
        break
19442 
      if fid == 1:
19443 
        if ftype == TType.I64:
19444 
          self.vendorId = iprot.readI64();
19445 
        else:
19446 
          iprot.skip(ftype)
19447 
      else:
19448 
        iprot.skip(ftype)
19449 
      iprot.readFieldEnd()
19450 
    iprot.readStructEnd()
19451 
 
19452 
  def write(self, oprot):
19453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19455 
      return
19456 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19457 
    if self.vendorId is not None:
19458 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19459 
      oprot.writeI64(self.vendorId)
19460 
      oprot.writeFieldEnd()
19461 
    oprot.writeFieldStop()
19462 
    oprot.writeStructEnd()
19463 
 
19464 
  def validate(self):
19465 
    return
19466 
 
19467 
 
19468 
  def __repr__(self):
19469 
    L = ['%s=%r' % (key, value)
19470 
      for key, value in self.__dict__.iteritems()]
19471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19472 
 
19473 
  def __eq__(self, other):
19474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19475 
 
19476 
  def __ne__(self, other):
19477 
    return not (self == other)
19478 
 
19479 
class markOrdersAsTimeout_result:
19480 
  """
19481 
  Attributes:
19482 
   - success
19483 
   - ex
19484 
  """
19485 
 
19486 
  thrift_spec = (
19487 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19489 
  )
19490 
 
19491 
  def __init__(self, success=None, ex=None,):
19492 
    self.success = success
19493 
    self.ex = ex
19494 
 
19495 
  def read(self, iprot):
19496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19498 
      return
19499 
    iprot.readStructBegin()
19500 
    while True:
19501 
      (fname, ftype, fid) = iprot.readFieldBegin()
19502 
      if ftype == TType.STOP:
19503 
        break
19504 
      if fid == 0:
19505 
        if ftype == TType.MAP:
19506 
          self.success = {}
5386 phani.kuma 19507 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
19508 
          for _i427 in xrange(_size423):
19509 
            _key428 = iprot.readI32();
19510 
            _val429 = TimeoutSummary()
19511 
            _val429.read(iprot)
19512 
            self.success[_key428] = _val429
4369 rajveer 19513 
          iprot.readMapEnd()
19514 
        else:
19515 
          iprot.skip(ftype)
19516 
      elif fid == 1:
19517 
        if ftype == TType.STRUCT:
19518 
          self.ex = TransactionServiceException()
19519 
          self.ex.read(iprot)
19520 
        else:
19521 
          iprot.skip(ftype)
19522 
      else:
19523 
        iprot.skip(ftype)
19524 
      iprot.readFieldEnd()
19525 
    iprot.readStructEnd()
19526 
 
19527 
  def write(self, oprot):
19528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19530 
      return
19531 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19532 
    if self.success is not None:
19533 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19534 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5386 phani.kuma 19535 
      for kiter430,viter431 in self.success.items():
19536 
        oprot.writeI32(kiter430)
19537 
        viter431.write(oprot)
4369 rajveer 19538 
      oprot.writeMapEnd()
19539 
      oprot.writeFieldEnd()
19540 
    if self.ex is not None:
19541 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19542 
      self.ex.write(oprot)
19543 
      oprot.writeFieldEnd()
19544 
    oprot.writeFieldStop()
19545 
    oprot.writeStructEnd()
19546 
 
19547 
  def validate(self):
19548 
    return
19549 
 
19550 
 
19551 
  def __repr__(self):
19552 
    L = ['%s=%r' % (key, value)
19553 
      for key, value in self.__dict__.iteritems()]
19554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19555 
 
19556 
  def __eq__(self, other):
19557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19558 
 
19559 
  def __ne__(self, other):
19560 
    return not (self == other)
4386 anupam.sin 19561 
 
4662 rajveer 19562 
class markOrderAsLostInTransit_args:
19563 
  """
19564 
  Attributes:
19565 
   - orderId
19566 
  """
19567 
 
19568 
  thrift_spec = (
19569 
    None, # 0
19570 
    (1, TType.I64, 'orderId', None, None, ), # 1
19571 
  )
19572 
 
19573 
  def __init__(self, orderId=None,):
19574 
    self.orderId = orderId
19575 
 
19576 
  def read(self, iprot):
19577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19579 
      return
19580 
    iprot.readStructBegin()
19581 
    while True:
19582 
      (fname, ftype, fid) = iprot.readFieldBegin()
19583 
      if ftype == TType.STOP:
19584 
        break
19585 
      if fid == 1:
19586 
        if ftype == TType.I64:
19587 
          self.orderId = iprot.readI64();
19588 
        else:
19589 
          iprot.skip(ftype)
19590 
      else:
19591 
        iprot.skip(ftype)
19592 
      iprot.readFieldEnd()
19593 
    iprot.readStructEnd()
19594 
 
19595 
  def write(self, oprot):
19596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19598 
      return
19599 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19600 
    if self.orderId is not None:
19601 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19602 
      oprot.writeI64(self.orderId)
19603 
      oprot.writeFieldEnd()
19604 
    oprot.writeFieldStop()
19605 
    oprot.writeStructEnd()
19606 
 
19607 
  def validate(self):
19608 
    return
19609 
 
19610 
 
19611 
  def __repr__(self):
19612 
    L = ['%s=%r' % (key, value)
19613 
      for key, value in self.__dict__.iteritems()]
19614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19615 
 
19616 
  def __eq__(self, other):
19617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19618 
 
19619 
  def __ne__(self, other):
19620 
    return not (self == other)
19621 
 
19622 
class markOrderAsLostInTransit_result:
19623 
  """
19624 
  Attributes:
19625 
   - success
19626 
   - ex
19627 
  """
19628 
 
19629 
  thrift_spec = (
19630 
    (0, TType.BOOL, 'success', None, None, ), # 0
19631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19632 
  )
19633 
 
19634 
  def __init__(self, success=None, ex=None,):
19635 
    self.success = success
19636 
    self.ex = ex
19637 
 
19638 
  def read(self, iprot):
19639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19641 
      return
19642 
    iprot.readStructBegin()
19643 
    while True:
19644 
      (fname, ftype, fid) = iprot.readFieldBegin()
19645 
      if ftype == TType.STOP:
19646 
        break
19647 
      if fid == 0:
19648 
        if ftype == TType.BOOL:
19649 
          self.success = iprot.readBool();
19650 
        else:
19651 
          iprot.skip(ftype)
19652 
      elif fid == 1:
19653 
        if ftype == TType.STRUCT:
19654 
          self.ex = TransactionServiceException()
19655 
          self.ex.read(iprot)
19656 
        else:
19657 
          iprot.skip(ftype)
19658 
      else:
19659 
        iprot.skip(ftype)
19660 
      iprot.readFieldEnd()
19661 
    iprot.readStructEnd()
19662 
 
19663 
  def write(self, oprot):
19664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19666 
      return
19667 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19668 
    if self.success is not None:
19669 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19670 
      oprot.writeBool(self.success)
19671 
      oprot.writeFieldEnd()
19672 
    if self.ex is not None:
19673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19674 
      self.ex.write(oprot)
19675 
      oprot.writeFieldEnd()
19676 
    oprot.writeFieldStop()
19677 
    oprot.writeStructEnd()
19678 
 
19679 
  def validate(self):
19680 
    return
19681 
 
19682 
 
19683 
  def __repr__(self):
19684 
    L = ['%s=%r' % (key, value)
19685 
      for key, value in self.__dict__.iteritems()]
19686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19687 
 
19688 
  def __eq__(self, other):
19689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19690 
 
19691 
  def __ne__(self, other):
19692 
    return not (self == other)
19693 
 
4386 anupam.sin 19694 
class getOrderForAwb_args:
19695 
  """
19696 
  Attributes:
19697 
   - awb
19698 
  """
19699 
 
19700 
  thrift_spec = (
19701 
    None, # 0
19702 
    (1, TType.STRING, 'awb', None, None, ), # 1
19703 
  )
19704 
 
19705 
  def __init__(self, awb=None,):
19706 
    self.awb = awb
19707 
 
19708 
  def read(self, iprot):
19709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19711 
      return
19712 
    iprot.readStructBegin()
19713 
    while True:
19714 
      (fname, ftype, fid) = iprot.readFieldBegin()
19715 
      if ftype == TType.STOP:
19716 
        break
19717 
      if fid == 1:
19718 
        if ftype == TType.STRING:
19719 
          self.awb = iprot.readString();
19720 
        else:
19721 
          iprot.skip(ftype)
19722 
      else:
19723 
        iprot.skip(ftype)
19724 
      iprot.readFieldEnd()
19725 
    iprot.readStructEnd()
19726 
 
19727 
  def write(self, oprot):
19728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19730 
      return
19731 
    oprot.writeStructBegin('getOrderForAwb_args')
19732 
    if self.awb is not None:
19733 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19734 
      oprot.writeString(self.awb)
19735 
      oprot.writeFieldEnd()
19736 
    oprot.writeFieldStop()
19737 
    oprot.writeStructEnd()
19738 
 
19739 
  def validate(self):
19740 
    return
19741 
 
19742 
 
19743 
  def __repr__(self):
19744 
    L = ['%s=%r' % (key, value)
19745 
      for key, value in self.__dict__.iteritems()]
19746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19747 
 
19748 
  def __eq__(self, other):
19749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19750 
 
19751 
  def __ne__(self, other):
19752 
    return not (self == other)
19753 
 
19754 
class getOrderForAwb_result:
19755 
  """
19756 
  Attributes:
19757 
   - success
19758 
   - ex
19759 
  """
19760 
 
19761 
  thrift_spec = (
19762 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19764 
  )
19765 
 
19766 
  def __init__(self, success=None, ex=None,):
19767 
    self.success = success
19768 
    self.ex = ex
19769 
 
19770 
  def read(self, iprot):
19771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19773 
      return
19774 
    iprot.readStructBegin()
19775 
    while True:
19776 
      (fname, ftype, fid) = iprot.readFieldBegin()
19777 
      if ftype == TType.STOP:
19778 
        break
19779 
      if fid == 0:
19780 
        if ftype == TType.STRUCT:
19781 
          self.success = Order()
19782 
          self.success.read(iprot)
19783 
        else:
19784 
          iprot.skip(ftype)
19785 
      elif fid == 1:
19786 
        if ftype == TType.STRUCT:
19787 
          self.ex = TransactionServiceException()
19788 
          self.ex.read(iprot)
19789 
        else:
19790 
          iprot.skip(ftype)
19791 
      else:
19792 
        iprot.skip(ftype)
19793 
      iprot.readFieldEnd()
19794 
    iprot.readStructEnd()
19795 
 
19796 
  def write(self, oprot):
19797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19799 
      return
19800 
    oprot.writeStructBegin('getOrderForAwb_result')
19801 
    if self.success is not None:
19802 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19803 
      self.success.write(oprot)
19804 
      oprot.writeFieldEnd()
19805 
    if self.ex is not None:
19806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19807 
      self.ex.write(oprot)
19808 
      oprot.writeFieldEnd()
19809 
    oprot.writeFieldStop()
19810 
    oprot.writeStructEnd()
19811 
 
19812 
  def validate(self):
19813 
    return
19814 
 
19815 
 
19816 
  def __repr__(self):
19817 
    L = ['%s=%r' % (key, value)
19818 
      for key, value in self.__dict__.iteritems()]
19819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19820 
 
19821 
  def __eq__(self, other):
19822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19823 
 
19824 
  def __ne__(self, other):
19825 
    return not (self == other)
4506 phani.kuma 19826 
 
19827 
class getOrdersForProviderForStatus_args:
19828 
  """
19829 
  Attributes:
19830 
   - logistics_provider_id
4910 phani.kuma 19831 
   - order_status_list
4506 phani.kuma 19832 
  """
19833 
 
19834 
  thrift_spec = (
19835 
    None, # 0
19836 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19837 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19838 
  )
19839 
 
4910 phani.kuma 19840 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19841 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19842 
    self.order_status_list = order_status_list
4506 phani.kuma 19843 
 
19844 
  def read(self, iprot):
19845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19847 
      return
19848 
    iprot.readStructBegin()
19849 
    while True:
19850 
      (fname, ftype, fid) = iprot.readFieldBegin()
19851 
      if ftype == TType.STOP:
19852 
        break
19853 
      if fid == 1:
19854 
        if ftype == TType.I64:
19855 
          self.logistics_provider_id = iprot.readI64();
19856 
        else:
19857 
          iprot.skip(ftype)
19858 
      elif fid == 2:
4910 phani.kuma 19859 
        if ftype == TType.LIST:
19860 
          self.order_status_list = []
5386 phani.kuma 19861 
          (_etype435, _size432) = iprot.readListBegin()
19862 
          for _i436 in xrange(_size432):
19863 
            _elem437 = iprot.readI32();
19864 
            self.order_status_list.append(_elem437)
4910 phani.kuma 19865 
          iprot.readListEnd()
4506 phani.kuma 19866 
        else:
19867 
          iprot.skip(ftype)
19868 
      else:
19869 
        iprot.skip(ftype)
19870 
      iprot.readFieldEnd()
19871 
    iprot.readStructEnd()
19872 
 
19873 
  def write(self, oprot):
19874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19876 
      return
19877 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19878 
    if self.logistics_provider_id is not None:
19879 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19880 
      oprot.writeI64(self.logistics_provider_id)
19881 
      oprot.writeFieldEnd()
4910 phani.kuma 19882 
    if self.order_status_list is not None:
19883 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19884 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5386 phani.kuma 19885 
      for iter438 in self.order_status_list:
19886 
        oprot.writeI32(iter438)
4910 phani.kuma 19887 
      oprot.writeListEnd()
4506 phani.kuma 19888 
      oprot.writeFieldEnd()
19889 
    oprot.writeFieldStop()
19890 
    oprot.writeStructEnd()
19891 
 
19892 
  def validate(self):
19893 
    return
19894 
 
19895 
 
19896 
  def __repr__(self):
19897 
    L = ['%s=%r' % (key, value)
19898 
      for key, value in self.__dict__.iteritems()]
19899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19900 
 
19901 
  def __eq__(self, other):
19902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19903 
 
19904 
  def __ne__(self, other):
19905 
    return not (self == other)
19906 
 
19907 
class getOrdersForProviderForStatus_result:
19908 
  """
19909 
  Attributes:
19910 
   - success
19911 
   - ex
19912 
  """
19913 
 
19914 
  thrift_spec = (
19915 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19917 
  )
19918 
 
19919 
  def __init__(self, success=None, ex=None,):
19920 
    self.success = success
19921 
    self.ex = ex
19922 
 
19923 
  def read(self, iprot):
19924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19926 
      return
19927 
    iprot.readStructBegin()
19928 
    while True:
19929 
      (fname, ftype, fid) = iprot.readFieldBegin()
19930 
      if ftype == TType.STOP:
19931 
        break
19932 
      if fid == 0:
19933 
        if ftype == TType.LIST:
19934 
          self.success = []
5386 phani.kuma 19935 
          (_etype442, _size439) = iprot.readListBegin()
19936 
          for _i443 in xrange(_size439):
19937 
            _elem444 = Order()
19938 
            _elem444.read(iprot)
19939 
            self.success.append(_elem444)
4506 phani.kuma 19940 
          iprot.readListEnd()
19941 
        else:
19942 
          iprot.skip(ftype)
19943 
      elif fid == 1:
19944 
        if ftype == TType.STRUCT:
19945 
          self.ex = TransactionServiceException()
19946 
          self.ex.read(iprot)
19947 
        else:
19948 
          iprot.skip(ftype)
19949 
      else:
19950 
        iprot.skip(ftype)
19951 
      iprot.readFieldEnd()
19952 
    iprot.readStructEnd()
19953 
 
19954 
  def write(self, oprot):
19955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19957 
      return
19958 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19959 
    if self.success is not None:
19960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 19962 
      for iter445 in self.success:
19963 
        iter445.write(oprot)
4506 phani.kuma 19964 
      oprot.writeListEnd()
19965 
      oprot.writeFieldEnd()
19966 
    if self.ex is not None:
19967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19968 
      self.ex.write(oprot)
19969 
      oprot.writeFieldEnd()
19970 
    oprot.writeFieldStop()
19971 
    oprot.writeStructEnd()
19972 
 
19973 
  def validate(self):
19974 
    return
19975 
 
19976 
 
19977 
  def __repr__(self):
19978 
    L = ['%s=%r' % (key, value)
19979 
      for key, value in self.__dict__.iteritems()]
19980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19981 
 
19982 
  def __eq__(self, other):
19983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19984 
 
19985 
  def __ne__(self, other):
19986 
    return not (self == other)
4600 varun.gupt 19987 
 
19988 
class getBilledOrdersForVendor_args:
19989 
  """
19990 
  Attributes:
19991 
   - vendorId
19992 
   - billingDateFrom
19993 
   - billingDateTo
19994 
  """
19995 
 
19996 
  thrift_spec = (
19997 
    None, # 0
19998 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19999 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20000 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20001 
  )
20002 
 
20003 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20004 
    self.vendorId = vendorId
20005 
    self.billingDateFrom = billingDateFrom
20006 
    self.billingDateTo = billingDateTo
20007 
 
20008 
  def read(self, iprot):
20009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20011 
      return
20012 
    iprot.readStructBegin()
20013 
    while True:
20014 
      (fname, ftype, fid) = iprot.readFieldBegin()
20015 
      if ftype == TType.STOP:
20016 
        break
20017 
      if fid == 1:
20018 
        if ftype == TType.I64:
20019 
          self.vendorId = iprot.readI64();
20020 
        else:
20021 
          iprot.skip(ftype)
20022 
      elif fid == 2:
20023 
        if ftype == TType.I64:
20024 
          self.billingDateFrom = iprot.readI64();
20025 
        else:
20026 
          iprot.skip(ftype)
20027 
      elif fid == 3:
20028 
        if ftype == TType.I64:
20029 
          self.billingDateTo = iprot.readI64();
20030 
        else:
20031 
          iprot.skip(ftype)
20032 
      else:
20033 
        iprot.skip(ftype)
20034 
      iprot.readFieldEnd()
20035 
    iprot.readStructEnd()
20036 
 
20037 
  def write(self, oprot):
20038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20040 
      return
20041 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20042 
    if self.vendorId is not None:
20043 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20044 
      oprot.writeI64(self.vendorId)
20045 
      oprot.writeFieldEnd()
20046 
    if self.billingDateFrom is not None:
20047 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20048 
      oprot.writeI64(self.billingDateFrom)
20049 
      oprot.writeFieldEnd()
20050 
    if self.billingDateTo is not None:
20051 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20052 
      oprot.writeI64(self.billingDateTo)
20053 
      oprot.writeFieldEnd()
20054 
    oprot.writeFieldStop()
20055 
    oprot.writeStructEnd()
20056 
 
20057 
  def validate(self):
20058 
    return
20059 
 
20060 
 
20061 
  def __repr__(self):
20062 
    L = ['%s=%r' % (key, value)
20063 
      for key, value in self.__dict__.iteritems()]
20064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20065 
 
20066 
  def __eq__(self, other):
20067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20068 
 
20069 
  def __ne__(self, other):
20070 
    return not (self == other)
20071 
 
20072 
class getBilledOrdersForVendor_result:
20073 
  """
20074 
  Attributes:
20075 
   - success
20076 
   - ex
20077 
  """
20078 
 
20079 
  thrift_spec = (
20080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20082 
  )
20083 
 
20084 
  def __init__(self, success=None, ex=None,):
20085 
    self.success = success
20086 
    self.ex = ex
20087 
 
20088 
  def read(self, iprot):
20089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20091 
      return
20092 
    iprot.readStructBegin()
20093 
    while True:
20094 
      (fname, ftype, fid) = iprot.readFieldBegin()
20095 
      if ftype == TType.STOP:
20096 
        break
20097 
      if fid == 0:
20098 
        if ftype == TType.LIST:
20099 
          self.success = []
5386 phani.kuma 20100 
          (_etype449, _size446) = iprot.readListBegin()
20101 
          for _i450 in xrange(_size446):
20102 
            _elem451 = Order()
20103 
            _elem451.read(iprot)
20104 
            self.success.append(_elem451)
4600 varun.gupt 20105 
          iprot.readListEnd()
20106 
        else:
20107 
          iprot.skip(ftype)
20108 
      elif fid == 1:
20109 
        if ftype == TType.STRUCT:
20110 
          self.ex = TransactionServiceException()
20111 
          self.ex.read(iprot)
20112 
        else:
20113 
          iprot.skip(ftype)
20114 
      else:
20115 
        iprot.skip(ftype)
20116 
      iprot.readFieldEnd()
20117 
    iprot.readStructEnd()
20118 
 
20119 
  def write(self, oprot):
20120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20122 
      return
20123 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20124 
    if self.success is not None:
20125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 20127 
      for iter452 in self.success:
20128 
        iter452.write(oprot)
4600 varun.gupt 20129 
      oprot.writeListEnd()
20130 
      oprot.writeFieldEnd()
20131 
    if self.ex is not None:
20132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20133 
      self.ex.write(oprot)
20134 
      oprot.writeFieldEnd()
20135 
    oprot.writeFieldStop()
20136 
    oprot.writeStructEnd()
20137 
 
20138 
  def validate(self):
20139 
    return
20140 
 
20141 
 
20142 
  def __repr__(self):
20143 
    L = ['%s=%r' % (key, value)
20144 
      for key, value in self.__dict__.iteritems()]
20145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20146 
 
20147 
  def __eq__(self, other):
20148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20149 
 
20150 
  def __ne__(self, other):
20151 
    return not (self == other)
20152 
 
4607 rajveer 20153 
class getSlippedSippingDateOrders_args:
20154 
 
20155 
  thrift_spec = (
20156 
  )
20157 
 
20158 
  def read(self, iprot):
20159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20161 
      return
20162 
    iprot.readStructBegin()
20163 
    while True:
20164 
      (fname, ftype, fid) = iprot.readFieldBegin()
20165 
      if ftype == TType.STOP:
20166 
        break
20167 
      else:
20168 
        iprot.skip(ftype)
20169 
      iprot.readFieldEnd()
20170 
    iprot.readStructEnd()
20171 
 
20172 
  def write(self, oprot):
20173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20175 
      return
20176 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20177 
    oprot.writeFieldStop()
20178 
    oprot.writeStructEnd()
20179 
 
20180 
  def validate(self):
20181 
    return
20182 
 
20183 
 
20184 
  def __repr__(self):
20185 
    L = ['%s=%r' % (key, value)
20186 
      for key, value in self.__dict__.iteritems()]
20187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20188 
 
20189 
  def __eq__(self, other):
20190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20191 
 
20192 
  def __ne__(self, other):
20193 
    return not (self == other)
20194 
 
20195 
class getSlippedSippingDateOrders_result:
20196 
  """
20197 
  Attributes:
20198 
   - success
20199 
   - ex
20200 
  """
20201 
 
20202 
  thrift_spec = (
20203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20205 
  )
20206 
 
20207 
  def __init__(self, success=None, ex=None,):
20208 
    self.success = success
20209 
    self.ex = ex
20210 
 
20211 
  def read(self, iprot):
20212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20214 
      return
20215 
    iprot.readStructBegin()
20216 
    while True:
20217 
      (fname, ftype, fid) = iprot.readFieldBegin()
20218 
      if ftype == TType.STOP:
20219 
        break
20220 
      if fid == 0:
20221 
        if ftype == TType.LIST:
20222 
          self.success = []
5386 phani.kuma 20223 
          (_etype456, _size453) = iprot.readListBegin()
20224 
          for _i457 in xrange(_size453):
20225 
            _elem458 = Order()
20226 
            _elem458.read(iprot)
20227 
            self.success.append(_elem458)
4607 rajveer 20228 
          iprot.readListEnd()
20229 
        else:
20230 
          iprot.skip(ftype)
20231 
      elif fid == 1:
20232 
        if ftype == TType.STRUCT:
20233 
          self.ex = TransactionServiceException()
20234 
          self.ex.read(iprot)
20235 
        else:
20236 
          iprot.skip(ftype)
20237 
      else:
20238 
        iprot.skip(ftype)
20239 
      iprot.readFieldEnd()
20240 
    iprot.readStructEnd()
20241 
 
20242 
  def write(self, oprot):
20243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20245 
      return
20246 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20247 
    if self.success is not None:
20248 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20249 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 20250 
      for iter459 in self.success:
20251 
        iter459.write(oprot)
4607 rajveer 20252 
      oprot.writeListEnd()
20253 
      oprot.writeFieldEnd()
20254 
    if self.ex is not None:
20255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20256 
      self.ex.write(oprot)
20257 
      oprot.writeFieldEnd()
20258 
    oprot.writeFieldStop()
20259 
    oprot.writeStructEnd()
20260 
 
20261 
  def validate(self):
20262 
    return
20263 
 
20264 
 
20265 
  def __repr__(self):
20266 
    L = ['%s=%r' % (key, value)
20267 
      for key, value in self.__dict__.iteritems()]
20268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20269 
 
20270 
  def __eq__(self, other):
20271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20272 
 
20273 
  def __ne__(self, other):
20274 
    return not (self == other)
20275 
 
4709 rajveer 20276 
class getCancelledOrders_args:
20277 
  """
20278 
  Attributes:
20279 
   - cancelDateFrom
20280 
   - cancelDateTo
20281 
  """
20282 
 
20283 
  thrift_spec = (
20284 
    None, # 0
20285 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20286 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20287 
  )
20288 
 
20289 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20290 
    self.cancelDateFrom = cancelDateFrom
20291 
    self.cancelDateTo = cancelDateTo
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.cancelDateFrom = iprot.readI64();
20305 
        else:
20306 
          iprot.skip(ftype)
20307 
      elif fid == 2:
20308 
        if ftype == TType.I64:
20309 
          self.cancelDateTo = iprot.readI64();
20310 
        else:
20311 
          iprot.skip(ftype)
20312 
      else:
20313 
        iprot.skip(ftype)
20314 
      iprot.readFieldEnd()
20315 
    iprot.readStructEnd()
20316 
 
20317 
  def write(self, oprot):
20318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20320 
      return
20321 
    oprot.writeStructBegin('getCancelledOrders_args')
20322 
    if self.cancelDateFrom is not None:
20323 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20324 
      oprot.writeI64(self.cancelDateFrom)
20325 
      oprot.writeFieldEnd()
20326 
    if self.cancelDateTo is not None:
20327 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20328 
      oprot.writeI64(self.cancelDateTo)
20329 
      oprot.writeFieldEnd()
20330 
    oprot.writeFieldStop()
20331 
    oprot.writeStructEnd()
20332 
 
20333 
  def validate(self):
20334 
    return
20335 
 
20336 
 
20337 
  def __repr__(self):
20338 
    L = ['%s=%r' % (key, value)
20339 
      for key, value in self.__dict__.iteritems()]
20340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20341 
 
20342 
  def __eq__(self, other):
20343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20344 
 
20345 
  def __ne__(self, other):
20346 
    return not (self == other)
20347 
 
20348 
class getCancelledOrders_result:
20349 
  """
20350 
  Attributes:
20351 
   - success
20352 
   - ex
20353 
  """
20354 
 
20355 
  thrift_spec = (
20356 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20358 
  )
20359 
 
20360 
  def __init__(self, success=None, ex=None,):
20361 
    self.success = success
20362 
    self.ex = ex
20363 
 
20364 
  def read(self, iprot):
20365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20367 
      return
20368 
    iprot.readStructBegin()
20369 
    while True:
20370 
      (fname, ftype, fid) = iprot.readFieldBegin()
20371 
      if ftype == TType.STOP:
20372 
        break
20373 
      if fid == 0:
20374 
        if ftype == TType.LIST:
20375 
          self.success = []
5386 phani.kuma 20376 
          (_etype463, _size460) = iprot.readListBegin()
20377 
          for _i464 in xrange(_size460):
20378 
            _elem465 = Order()
20379 
            _elem465.read(iprot)
20380 
            self.success.append(_elem465)
4709 rajveer 20381 
          iprot.readListEnd()
20382 
        else:
20383 
          iprot.skip(ftype)
20384 
      elif fid == 1:
20385 
        if ftype == TType.STRUCT:
20386 
          self.ex = TransactionServiceException()
20387 
          self.ex.read(iprot)
20388 
        else:
20389 
          iprot.skip(ftype)
20390 
      else:
20391 
        iprot.skip(ftype)
20392 
      iprot.readFieldEnd()
20393 
    iprot.readStructEnd()
20394 
 
20395 
  def write(self, oprot):
20396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20398 
      return
20399 
    oprot.writeStructBegin('getCancelledOrders_result')
20400 
    if self.success is not None:
20401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 20403 
      for iter466 in self.success:
20404 
        iter466.write(oprot)
4709 rajveer 20405 
      oprot.writeListEnd()
20406 
      oprot.writeFieldEnd()
20407 
    if self.ex is not None:
20408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20409 
      self.ex.write(oprot)
20410 
      oprot.writeFieldEnd()
20411 
    oprot.writeFieldStop()
20412 
    oprot.writeStructEnd()
20413 
 
20414 
  def validate(self):
20415 
    return
20416 
 
20417 
 
20418 
  def __repr__(self):
20419 
    L = ['%s=%r' % (key, value)
20420 
      for key, value in self.__dict__.iteritems()]
20421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20422 
 
20423 
  def __eq__(self, other):
20424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20425 
 
20426 
  def __ne__(self, other):
20427 
    return not (self == other)
20428 
 
4600 varun.gupt 20429 
class saveBluedartSettlements_args:
20430 
  """
20431 
  Attributes:
20432 
   - mapAWBAndAmount
20433 
  """
20434 
 
20435 
  thrift_spec = (
20436 
    None, # 0
20437 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20438 
  )
20439 
 
20440 
  def __init__(self, mapAWBAndAmount=None,):
20441 
    self.mapAWBAndAmount = mapAWBAndAmount
20442 
 
20443 
  def read(self, iprot):
20444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20446 
      return
20447 
    iprot.readStructBegin()
20448 
    while True:
20449 
      (fname, ftype, fid) = iprot.readFieldBegin()
20450 
      if ftype == TType.STOP:
20451 
        break
20452 
      if fid == 1:
20453 
        if ftype == TType.MAP:
20454 
          self.mapAWBAndAmount = {}
5386 phani.kuma 20455 
          (_ktype468, _vtype469, _size467 ) = iprot.readMapBegin()
20456 
          for _i471 in xrange(_size467):
20457 
            _key472 = iprot.readI64();
20458 
            _val473 = iprot.readDouble();
20459 
            self.mapAWBAndAmount[_key472] = _val473
4600 varun.gupt 20460 
          iprot.readMapEnd()
20461 
        else:
20462 
          iprot.skip(ftype)
20463 
      else:
20464 
        iprot.skip(ftype)
20465 
      iprot.readFieldEnd()
20466 
    iprot.readStructEnd()
20467 
 
20468 
  def write(self, oprot):
20469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20471 
      return
20472 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20473 
    if self.mapAWBAndAmount is not None:
20474 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20475 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5386 phani.kuma 20476 
      for kiter474,viter475 in self.mapAWBAndAmount.items():
20477 
        oprot.writeI64(kiter474)
20478 
        oprot.writeDouble(viter475)
4600 varun.gupt 20479 
      oprot.writeMapEnd()
20480 
      oprot.writeFieldEnd()
20481 
    oprot.writeFieldStop()
20482 
    oprot.writeStructEnd()
20483 
 
20484 
  def validate(self):
20485 
    return
20486 
 
20487 
 
20488 
  def __repr__(self):
20489 
    L = ['%s=%r' % (key, value)
20490 
      for key, value in self.__dict__.iteritems()]
20491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20492 
 
20493 
  def __eq__(self, other):
20494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20495 
 
20496 
  def __ne__(self, other):
20497 
    return not (self == other)
20498 
 
20499 
class saveBluedartSettlements_result:
20500 
  """
20501 
  Attributes:
20502 
   - ex
20503 
  """
20504 
 
20505 
  thrift_spec = (
20506 
    None, # 0
20507 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20508 
  )
20509 
 
20510 
  def __init__(self, ex=None,):
20511 
    self.ex = ex
20512 
 
20513 
  def read(self, iprot):
20514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20516 
      return
20517 
    iprot.readStructBegin()
20518 
    while True:
20519 
      (fname, ftype, fid) = iprot.readFieldBegin()
20520 
      if ftype == TType.STOP:
20521 
        break
20522 
      if fid == 1:
20523 
        if ftype == TType.STRUCT:
20524 
          self.ex = TransactionServiceException()
20525 
          self.ex.read(iprot)
20526 
        else:
20527 
          iprot.skip(ftype)
20528 
      else:
20529 
        iprot.skip(ftype)
20530 
      iprot.readFieldEnd()
20531 
    iprot.readStructEnd()
20532 
 
20533 
  def write(self, oprot):
20534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20536 
      return
20537 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20538 
    if self.ex is not None:
20539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20540 
      self.ex.write(oprot)
20541 
      oprot.writeFieldEnd()
20542 
    oprot.writeFieldStop()
20543 
    oprot.writeStructEnd()
20544 
 
20545 
  def validate(self):
20546 
    return
20547 
 
20548 
 
20549 
  def __repr__(self):
20550 
    L = ['%s=%r' % (key, value)
20551 
      for key, value in self.__dict__.iteritems()]
20552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20553 
 
20554 
  def __eq__(self, other):
20555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20556 
 
20557 
  def __ne__(self, other):
20558 
    return not (self == other)
20559 
 
20560 
class savePaymentSettlements_args:
20561 
  """
20562 
  Attributes:
20563 
   - settlementDate
20564 
   - paymentGatewayId
4905 varun.gupt 20565 
   - referenceId
4600 varun.gupt 20566 
   - serviceTax
20567 
   - otherCharges
20568 
   - netCollection
20569 
  """
20570 
 
20571 
  thrift_spec = (
20572 
    None, # 0
20573 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20574 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20575 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20576 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20577 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20578 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20579 
  )
20580 
 
4905 varun.gupt 20581 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20582 
    self.settlementDate = settlementDate
20583 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20584 
    self.referenceId = referenceId
4600 varun.gupt 20585 
    self.serviceTax = serviceTax
20586 
    self.otherCharges = otherCharges
20587 
    self.netCollection = netCollection
20588 
 
20589 
  def read(self, iprot):
20590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20592 
      return
20593 
    iprot.readStructBegin()
20594 
    while True:
20595 
      (fname, ftype, fid) = iprot.readFieldBegin()
20596 
      if ftype == TType.STOP:
20597 
        break
20598 
      if fid == 1:
20599 
        if ftype == TType.I64:
20600 
          self.settlementDate = iprot.readI64();
20601 
        else:
20602 
          iprot.skip(ftype)
20603 
      elif fid == 2:
20604 
        if ftype == TType.I64:
20605 
          self.paymentGatewayId = iprot.readI64();
20606 
        else:
20607 
          iprot.skip(ftype)
20608 
      elif fid == 3:
20609 
        if ftype == TType.I64:
4905 varun.gupt 20610 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20611 
        else:
20612 
          iprot.skip(ftype)
20613 
      elif fid == 4:
20614 
        if ftype == TType.DOUBLE:
20615 
          self.serviceTax = iprot.readDouble();
20616 
        else:
20617 
          iprot.skip(ftype)
20618 
      elif fid == 5:
20619 
        if ftype == TType.DOUBLE:
20620 
          self.otherCharges = iprot.readDouble();
20621 
        else:
20622 
          iprot.skip(ftype)
20623 
      elif fid == 6:
20624 
        if ftype == TType.DOUBLE:
20625 
          self.netCollection = iprot.readDouble();
20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      else:
20629 
        iprot.skip(ftype)
20630 
      iprot.readFieldEnd()
20631 
    iprot.readStructEnd()
20632 
 
20633 
  def write(self, oprot):
20634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20636 
      return
20637 
    oprot.writeStructBegin('savePaymentSettlements_args')
20638 
    if self.settlementDate is not None:
20639 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20640 
      oprot.writeI64(self.settlementDate)
20641 
      oprot.writeFieldEnd()
20642 
    if self.paymentGatewayId is not None:
20643 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20644 
      oprot.writeI64(self.paymentGatewayId)
20645 
      oprot.writeFieldEnd()
4905 varun.gupt 20646 
    if self.referenceId is not None:
20647 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20648 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20649 
      oprot.writeFieldEnd()
20650 
    if self.serviceTax is not None:
20651 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20652 
      oprot.writeDouble(self.serviceTax)
20653 
      oprot.writeFieldEnd()
20654 
    if self.otherCharges is not None:
20655 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20656 
      oprot.writeDouble(self.otherCharges)
20657 
      oprot.writeFieldEnd()
20658 
    if self.netCollection is not None:
20659 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20660 
      oprot.writeDouble(self.netCollection)
20661 
      oprot.writeFieldEnd()
20662 
    oprot.writeFieldStop()
20663 
    oprot.writeStructEnd()
20664 
 
20665 
  def validate(self):
20666 
    return
20667 
 
20668 
 
20669 
  def __repr__(self):
20670 
    L = ['%s=%r' % (key, value)
20671 
      for key, value in self.__dict__.iteritems()]
20672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20673 
 
20674 
  def __eq__(self, other):
20675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20676 
 
20677 
  def __ne__(self, other):
20678 
    return not (self == other)
20679 
 
20680 
class savePaymentSettlements_result:
20681 
  """
20682 
  Attributes:
20683 
   - ex
20684 
  """
20685 
 
20686 
  thrift_spec = (
20687 
    None, # 0
20688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20689 
  )
20690 
 
20691 
  def __init__(self, ex=None,):
20692 
    self.ex = ex
20693 
 
20694 
  def read(self, iprot):
20695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20697 
      return
20698 
    iprot.readStructBegin()
20699 
    while True:
20700 
      (fname, ftype, fid) = iprot.readFieldBegin()
20701 
      if ftype == TType.STOP:
20702 
        break
20703 
      if fid == 1:
20704 
        if ftype == TType.STRUCT:
20705 
          self.ex = TransactionServiceException()
20706 
          self.ex.read(iprot)
20707 
        else:
20708 
          iprot.skip(ftype)
20709 
      else:
20710 
        iprot.skip(ftype)
20711 
      iprot.readFieldEnd()
20712 
    iprot.readStructEnd()
20713 
 
20714 
  def write(self, oprot):
20715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20717 
      return
20718 
    oprot.writeStructBegin('savePaymentSettlements_result')
20719 
    if self.ex is not None:
20720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20721 
      self.ex.write(oprot)
20722 
      oprot.writeFieldEnd()
20723 
    oprot.writeFieldStop()
20724 
    oprot.writeStructEnd()
20725 
 
20726 
  def validate(self):
20727 
    return
20728 
 
20729 
 
20730 
  def __repr__(self):
20731 
    L = ['%s=%r' % (key, value)
20732 
      for key, value in self.__dict__.iteritems()]
20733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20734 
 
20735 
  def __eq__(self, other):
20736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20737 
 
20738 
  def __ne__(self, other):
20739 
    return not (self == other)
20740 
 
20741 
class saveEBSSettlementSummary_args:
20742 
  """
20743 
  Attributes:
20744 
   - settlementId
20745 
   - settlementDate
20746 
   - transactionDateFrom
20747 
   - transactionDateTo
20748 
   - amount
20749 
  """
20750 
 
20751 
  thrift_spec = (
20752 
    None, # 0
20753 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20754 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20755 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20756 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20757 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20758 
  )
20759 
 
20760 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20761 
    self.settlementId = settlementId
20762 
    self.settlementDate = settlementDate
20763 
    self.transactionDateFrom = transactionDateFrom
20764 
    self.transactionDateTo = transactionDateTo
20765 
    self.amount = amount
20766 
 
20767 
  def read(self, iprot):
20768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20770 
      return
20771 
    iprot.readStructBegin()
20772 
    while True:
20773 
      (fname, ftype, fid) = iprot.readFieldBegin()
20774 
      if ftype == TType.STOP:
20775 
        break
20776 
      if fid == 1:
20777 
        if ftype == TType.I64:
20778 
          self.settlementId = iprot.readI64();
20779 
        else:
20780 
          iprot.skip(ftype)
20781 
      elif fid == 2:
20782 
        if ftype == TType.I64:
20783 
          self.settlementDate = iprot.readI64();
20784 
        else:
20785 
          iprot.skip(ftype)
20786 
      elif fid == 3:
20787 
        if ftype == TType.I64:
20788 
          self.transactionDateFrom = iprot.readI64();
20789 
        else:
20790 
          iprot.skip(ftype)
20791 
      elif fid == 4:
20792 
        if ftype == TType.I64:
20793 
          self.transactionDateTo = iprot.readI64();
20794 
        else:
20795 
          iprot.skip(ftype)
20796 
      elif fid == 5:
20797 
        if ftype == TType.DOUBLE:
20798 
          self.amount = iprot.readDouble();
20799 
        else:
20800 
          iprot.skip(ftype)
20801 
      else:
20802 
        iprot.skip(ftype)
20803 
      iprot.readFieldEnd()
20804 
    iprot.readStructEnd()
20805 
 
20806 
  def write(self, oprot):
20807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20809 
      return
20810 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20811 
    if self.settlementId is not None:
20812 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20813 
      oprot.writeI64(self.settlementId)
20814 
      oprot.writeFieldEnd()
20815 
    if self.settlementDate is not None:
20816 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20817 
      oprot.writeI64(self.settlementDate)
20818 
      oprot.writeFieldEnd()
20819 
    if self.transactionDateFrom is not None:
20820 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20821 
      oprot.writeI64(self.transactionDateFrom)
20822 
      oprot.writeFieldEnd()
20823 
    if self.transactionDateTo is not None:
20824 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20825 
      oprot.writeI64(self.transactionDateTo)
20826 
      oprot.writeFieldEnd()
20827 
    if self.amount is not None:
20828 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20829 
      oprot.writeDouble(self.amount)
20830 
      oprot.writeFieldEnd()
20831 
    oprot.writeFieldStop()
20832 
    oprot.writeStructEnd()
20833 
 
20834 
  def validate(self):
20835 
    return
20836 
 
20837 
 
20838 
  def __repr__(self):
20839 
    L = ['%s=%r' % (key, value)
20840 
      for key, value in self.__dict__.iteritems()]
20841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20842 
 
20843 
  def __eq__(self, other):
20844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20845 
 
20846 
  def __ne__(self, other):
20847 
    return not (self == other)
20848 
 
20849 
class saveEBSSettlementSummary_result:
20850 
  """
20851 
  Attributes:
20852 
   - ex
20853 
  """
20854 
 
20855 
  thrift_spec = (
20856 
    None, # 0
20857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20858 
  )
20859 
 
20860 
  def __init__(self, ex=None,):
20861 
    self.ex = ex
20862 
 
20863 
  def read(self, iprot):
20864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20866 
      return
20867 
    iprot.readStructBegin()
20868 
    while True:
20869 
      (fname, ftype, fid) = iprot.readFieldBegin()
20870 
      if ftype == TType.STOP:
20871 
        break
20872 
      if fid == 1:
20873 
        if ftype == TType.STRUCT:
20874 
          self.ex = TransactionServiceException()
20875 
          self.ex.read(iprot)
20876 
        else:
20877 
          iprot.skip(ftype)
20878 
      else:
20879 
        iprot.skip(ftype)
20880 
      iprot.readFieldEnd()
20881 
    iprot.readStructEnd()
20882 
 
20883 
  def write(self, oprot):
20884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20886 
      return
20887 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20888 
    if self.ex is not None:
20889 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20890 
      self.ex.write(oprot)
20891 
      oprot.writeFieldEnd()
20892 
    oprot.writeFieldStop()
20893 
    oprot.writeStructEnd()
20894 
 
20895 
  def validate(self):
20896 
    return
20897 
 
20898 
 
20899 
  def __repr__(self):
20900 
    L = ['%s=%r' % (key, value)
20901 
      for key, value in self.__dict__.iteritems()]
20902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20903 
 
20904 
  def __eq__(self, other):
20905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20906 
 
20907 
  def __ne__(self, other):
20908 
    return not (self == other)
20909 
 
5386 phani.kuma 20910 
class getSettlementForPrepaid_args:
4600 varun.gupt 20911 
  """
20912 
  Attributes:
5189 varun.gupt 20913 
   - referenceId
20914 
   - isRefund
4600 varun.gupt 20915 
  """
20916 
 
20917 
  thrift_spec = (
20918 
    None, # 0
5189 varun.gupt 20919 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 20920 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20921 
  )
20922 
 
5386 phani.kuma 20923 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 20924 
    self.referenceId = referenceId
20925 
    self.isRefund = isRefund
4600 varun.gupt 20926 
 
20927 
  def read(self, iprot):
20928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20930 
      return
20931 
    iprot.readStructBegin()
20932 
    while True:
20933 
      (fname, ftype, fid) = iprot.readFieldBegin()
20934 
      if ftype == TType.STOP:
20935 
        break
20936 
      if fid == 1:
20937 
        if ftype == TType.I64:
5189 varun.gupt 20938 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20939 
        else:
20940 
          iprot.skip(ftype)
5189 varun.gupt 20941 
      elif fid == 2:
20942 
        if ftype == TType.BOOL:
20943 
          self.isRefund = iprot.readBool();
20944 
        else:
20945 
          iprot.skip(ftype)
4600 varun.gupt 20946 
      else:
20947 
        iprot.skip(ftype)
20948 
      iprot.readFieldEnd()
20949 
    iprot.readStructEnd()
20950 
 
20951 
  def write(self, oprot):
20952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20954 
      return
5386 phani.kuma 20955 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 20956 
    if self.referenceId is not None:
20957 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20958 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20959 
      oprot.writeFieldEnd()
5386 phani.kuma 20960 
    if self.isRefund is not None:
20961 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20962 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 20963 
      oprot.writeFieldEnd()
5386 phani.kuma 20964 
    oprot.writeFieldStop()
20965 
    oprot.writeStructEnd()
20966 
 
20967 
  def validate(self):
20968 
    return
20969 
 
20970 
 
20971 
  def __repr__(self):
20972 
    L = ['%s=%r' % (key, value)
20973 
      for key, value in self.__dict__.iteritems()]
20974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20975 
 
20976 
  def __eq__(self, other):
20977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20978 
 
20979 
  def __ne__(self, other):
20980 
    return not (self == other)
20981 
 
20982 
class getSettlementForPrepaid_result:
20983 
  """
20984 
  Attributes:
20985 
   - success
20986 
   - ex
20987 
  """
20988 
 
20989 
  thrift_spec = (
20990 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20992 
  )
20993 
 
20994 
  def __init__(self, success=None, ex=None,):
20995 
    self.success = success
20996 
    self.ex = ex
20997 
 
20998 
  def read(self, iprot):
20999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21001 
      return
21002 
    iprot.readStructBegin()
21003 
    while True:
21004 
      (fname, ftype, fid) = iprot.readFieldBegin()
21005 
      if ftype == TType.STOP:
21006 
        break
21007 
      if fid == 0:
21008 
        if ftype == TType.STRUCT:
21009 
          self.success = PaymentSettlement()
21010 
          self.success.read(iprot)
21011 
        else:
21012 
          iprot.skip(ftype)
21013 
      elif fid == 1:
21014 
        if ftype == TType.STRUCT:
21015 
          self.ex = TransactionServiceException()
21016 
          self.ex.read(iprot)
21017 
        else:
21018 
          iprot.skip(ftype)
21019 
      else:
21020 
        iprot.skip(ftype)
21021 
      iprot.readFieldEnd()
21022 
    iprot.readStructEnd()
21023 
 
21024 
  def write(self, oprot):
21025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21027 
      return
21028 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21029 
    if self.success is not None:
21030 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21031 
      self.success.write(oprot)
21032 
      oprot.writeFieldEnd()
21033 
    if self.ex is not None:
21034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21035 
      self.ex.write(oprot)
21036 
      oprot.writeFieldEnd()
21037 
    oprot.writeFieldStop()
21038 
    oprot.writeStructEnd()
21039 
 
21040 
  def validate(self):
21041 
    return
21042 
 
21043 
 
21044 
  def __repr__(self):
21045 
    L = ['%s=%r' % (key, value)
21046 
      for key, value in self.__dict__.iteritems()]
21047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21048 
 
21049 
  def __eq__(self, other):
21050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21051 
 
21052 
  def __ne__(self, other):
21053 
    return not (self == other)
21054 
 
21055 
class getSettlementForCod_args:
21056 
  """
21057 
  Attributes:
21058 
   - orderId
21059 
   - isRefund
21060 
  """
21061 
 
21062 
  thrift_spec = (
21063 
    None, # 0
21064 
    (1, TType.I64, 'orderId', None, None, ), # 1
21065 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21066 
  )
21067 
 
21068 
  def __init__(self, orderId=None, isRefund=None,):
21069 
    self.orderId = orderId
21070 
    self.isRefund = isRefund
21071 
 
21072 
  def read(self, iprot):
21073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21075 
      return
21076 
    iprot.readStructBegin()
21077 
    while True:
21078 
      (fname, ftype, fid) = iprot.readFieldBegin()
21079 
      if ftype == TType.STOP:
21080 
        break
21081 
      if fid == 1:
21082 
        if ftype == TType.I64:
21083 
          self.orderId = iprot.readI64();
21084 
        else:
21085 
          iprot.skip(ftype)
21086 
      elif fid == 2:
21087 
        if ftype == TType.BOOL:
21088 
          self.isRefund = iprot.readBool();
21089 
        else:
21090 
          iprot.skip(ftype)
21091 
      else:
21092 
        iprot.skip(ftype)
21093 
      iprot.readFieldEnd()
21094 
    iprot.readStructEnd()
21095 
 
21096 
  def write(self, oprot):
21097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21099 
      return
21100 
    oprot.writeStructBegin('getSettlementForCod_args')
21101 
    if self.orderId is not None:
21102 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21103 
      oprot.writeI64(self.orderId)
21104 
      oprot.writeFieldEnd()
5189 varun.gupt 21105 
    if self.isRefund is not None:
5386 phani.kuma 21106 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21107 
      oprot.writeBool(self.isRefund)
21108 
      oprot.writeFieldEnd()
4600 varun.gupt 21109 
    oprot.writeFieldStop()
21110 
    oprot.writeStructEnd()
21111 
 
21112 
  def validate(self):
21113 
    return
21114 
 
21115 
 
21116 
  def __repr__(self):
21117 
    L = ['%s=%r' % (key, value)
21118 
      for key, value in self.__dict__.iteritems()]
21119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21120 
 
21121 
  def __eq__(self, other):
21122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21123 
 
21124 
  def __ne__(self, other):
21125 
    return not (self == other)
21126 
 
5386 phani.kuma 21127 
class getSettlementForCod_result:
4600 varun.gupt 21128 
  """
21129 
  Attributes:
21130 
   - success
21131 
   - ex
21132 
  """
21133 
 
21134 
  thrift_spec = (
21135 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21137 
  )
21138 
 
21139 
  def __init__(self, success=None, ex=None,):
21140 
    self.success = success
21141 
    self.ex = ex
21142 
 
21143 
  def read(self, iprot):
21144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21146 
      return
21147 
    iprot.readStructBegin()
21148 
    while True:
21149 
      (fname, ftype, fid) = iprot.readFieldBegin()
21150 
      if ftype == TType.STOP:
21151 
        break
21152 
      if fid == 0:
21153 
        if ftype == TType.STRUCT:
21154 
          self.success = PaymentSettlement()
21155 
          self.success.read(iprot)
21156 
        else:
21157 
          iprot.skip(ftype)
21158 
      elif fid == 1:
21159 
        if ftype == TType.STRUCT:
21160 
          self.ex = TransactionServiceException()
21161 
          self.ex.read(iprot)
21162 
        else:
21163 
          iprot.skip(ftype)
21164 
      else:
21165 
        iprot.skip(ftype)
21166 
      iprot.readFieldEnd()
21167 
    iprot.readStructEnd()
21168 
 
21169 
  def write(self, oprot):
21170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21172 
      return
5386 phani.kuma 21173 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21174 
    if self.success is not None:
21175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21176 
      self.success.write(oprot)
21177 
      oprot.writeFieldEnd()
21178 
    if self.ex is not None:
21179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21180 
      self.ex.write(oprot)
21181 
      oprot.writeFieldEnd()
21182 
    oprot.writeFieldStop()
21183 
    oprot.writeStructEnd()
21184 
 
21185 
  def validate(self):
21186 
    return
21187 
 
21188 
 
21189 
  def __repr__(self):
21190 
    L = ['%s=%r' % (key, value)
21191 
      for key, value in self.__dict__.iteritems()]
21192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21193 
 
21194 
  def __eq__(self, other):
21195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21196 
 
21197 
  def __ne__(self, other):
21198 
    return not (self == other)
21199 
 
21200 
class getEBSSettlementSummaries_args:
21201 
 
21202 
  thrift_spec = (
21203 
  )
21204 
 
21205 
  def read(self, iprot):
21206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21208 
      return
21209 
    iprot.readStructBegin()
21210 
    while True:
21211 
      (fname, ftype, fid) = iprot.readFieldBegin()
21212 
      if ftype == TType.STOP:
21213 
        break
21214 
      else:
21215 
        iprot.skip(ftype)
21216 
      iprot.readFieldEnd()
21217 
    iprot.readStructEnd()
21218 
 
21219 
  def write(self, oprot):
21220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21222 
      return
21223 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21224 
    oprot.writeFieldStop()
21225 
    oprot.writeStructEnd()
21226 
 
21227 
  def validate(self):
21228 
    return
21229 
 
21230 
 
21231 
  def __repr__(self):
21232 
    L = ['%s=%r' % (key, value)
21233 
      for key, value in self.__dict__.iteritems()]
21234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21235 
 
21236 
  def __eq__(self, other):
21237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21238 
 
21239 
  def __ne__(self, other):
21240 
    return not (self == other)
21241 
 
21242 
class getEBSSettlementSummaries_result:
21243 
  """
21244 
  Attributes:
21245 
   - success
21246 
   - ex
21247 
  """
21248 
 
21249 
  thrift_spec = (
21250 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21252 
  )
21253 
 
21254 
  def __init__(self, success=None, ex=None,):
21255 
    self.success = success
21256 
    self.ex = ex
21257 
 
21258 
  def read(self, iprot):
21259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21261 
      return
21262 
    iprot.readStructBegin()
21263 
    while True:
21264 
      (fname, ftype, fid) = iprot.readFieldBegin()
21265 
      if ftype == TType.STOP:
21266 
        break
21267 
      if fid == 0:
21268 
        if ftype == TType.MAP:
21269 
          self.success = {}
5386 phani.kuma 21270 
          (_ktype477, _vtype478, _size476 ) = iprot.readMapBegin()
21271 
          for _i480 in xrange(_size476):
21272 
            _key481 = iprot.readI64();
21273 
            _val482 = iprot.readString();
21274 
            self.success[_key481] = _val482
4600 varun.gupt 21275 
          iprot.readMapEnd()
21276 
        else:
21277 
          iprot.skip(ftype)
21278 
      elif fid == 1:
21279 
        if ftype == TType.STRUCT:
21280 
          self.ex = TransactionServiceException()
21281 
          self.ex.read(iprot)
21282 
        else:
21283 
          iprot.skip(ftype)
21284 
      else:
21285 
        iprot.skip(ftype)
21286 
      iprot.readFieldEnd()
21287 
    iprot.readStructEnd()
21288 
 
21289 
  def write(self, oprot):
21290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21292 
      return
21293 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
21294 
    if self.success is not None:
21295 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21296 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5386 phani.kuma 21297 
      for kiter483,viter484 in self.success.items():
21298 
        oprot.writeI64(kiter483)
21299 
        oprot.writeString(viter484)
4600 varun.gupt 21300 
      oprot.writeMapEnd()
21301 
      oprot.writeFieldEnd()
21302 
    if self.ex is not None:
21303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21304 
      self.ex.write(oprot)
21305 
      oprot.writeFieldEnd()
21306 
    oprot.writeFieldStop()
21307 
    oprot.writeStructEnd()
21308 
 
21309 
  def validate(self):
21310 
    return
21311 
 
21312 
 
21313 
  def __repr__(self):
21314 
    L = ['%s=%r' % (key, value)
21315 
      for key, value in self.__dict__.iteritems()]
21316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21317 
 
21318 
  def __eq__(self, other):
21319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21320 
 
21321 
  def __ne__(self, other):
21322 
    return not (self == other)
21323 
 
21324 
class markEBSSettlementUploaded_args:
21325 
  """
21326 
  Attributes:
21327 
   - settlementId
21328 
  """
21329 
 
21330 
  thrift_spec = (
21331 
    None, # 0
21332 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21333 
  )
21334 
 
21335 
  def __init__(self, settlementId=None,):
21336 
    self.settlementId = settlementId
21337 
 
21338 
  def read(self, iprot):
21339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21341 
      return
21342 
    iprot.readStructBegin()
21343 
    while True:
21344 
      (fname, ftype, fid) = iprot.readFieldBegin()
21345 
      if ftype == TType.STOP:
21346 
        break
21347 
      if fid == 1:
21348 
        if ftype == TType.I64:
21349 
          self.settlementId = iprot.readI64();
21350 
        else:
21351 
          iprot.skip(ftype)
21352 
      else:
21353 
        iprot.skip(ftype)
21354 
      iprot.readFieldEnd()
21355 
    iprot.readStructEnd()
21356 
 
21357 
  def write(self, oprot):
21358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21360 
      return
21361 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
21362 
    if self.settlementId is not None:
21363 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21364 
      oprot.writeI64(self.settlementId)
21365 
      oprot.writeFieldEnd()
21366 
    oprot.writeFieldStop()
21367 
    oprot.writeStructEnd()
21368 
 
21369 
  def validate(self):
21370 
    return
21371 
 
21372 
 
21373 
  def __repr__(self):
21374 
    L = ['%s=%r' % (key, value)
21375 
      for key, value in self.__dict__.iteritems()]
21376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21377 
 
21378 
  def __eq__(self, other):
21379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21380 
 
21381 
  def __ne__(self, other):
21382 
    return not (self == other)
21383 
 
21384 
class markEBSSettlementUploaded_result:
21385 
  """
21386 
  Attributes:
21387 
   - ex
21388 
  """
21389 
 
21390 
  thrift_spec = (
21391 
    None, # 0
21392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21393 
  )
21394 
 
21395 
  def __init__(self, ex=None,):
21396 
    self.ex = ex
21397 
 
21398 
  def read(self, iprot):
21399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21401 
      return
21402 
    iprot.readStructBegin()
21403 
    while True:
21404 
      (fname, ftype, fid) = iprot.readFieldBegin()
21405 
      if ftype == TType.STOP:
21406 
        break
21407 
      if fid == 1:
21408 
        if ftype == TType.STRUCT:
21409 
          self.ex = TransactionServiceException()
21410 
          self.ex.read(iprot)
21411 
        else:
21412 
          iprot.skip(ftype)
21413 
      else:
21414 
        iprot.skip(ftype)
21415 
      iprot.readFieldEnd()
21416 
    iprot.readStructEnd()
21417 
 
21418 
  def write(self, oprot):
21419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21421 
      return
21422 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21423 
    if self.ex is not None:
21424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21425 
      self.ex.write(oprot)
21426 
      oprot.writeFieldEnd()
21427 
    oprot.writeFieldStop()
21428 
    oprot.writeStructEnd()
21429 
 
21430 
  def validate(self):
21431 
    return
21432 
 
21433 
 
21434 
  def __repr__(self):
21435 
    L = ['%s=%r' % (key, value)
21436 
      for key, value in self.__dict__.iteritems()]
21437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21438 
 
21439 
  def __eq__(self, other):
21440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21441 
 
21442 
  def __ne__(self, other):
21443 
    return not (self == other)
21444 
 
21445 
class getEBSSettlementDate_args:
21446 
  """
21447 
  Attributes:
21448 
   - settlementId
21449 
  """
21450 
 
21451 
  thrift_spec = (
21452 
    None, # 0
21453 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21454 
  )
21455 
 
21456 
  def __init__(self, settlementId=None,):
21457 
    self.settlementId = settlementId
21458 
 
21459 
  def read(self, iprot):
21460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21462 
      return
21463 
    iprot.readStructBegin()
21464 
    while True:
21465 
      (fname, ftype, fid) = iprot.readFieldBegin()
21466 
      if ftype == TType.STOP:
21467 
        break
21468 
      if fid == 1:
21469 
        if ftype == TType.I64:
21470 
          self.settlementId = iprot.readI64();
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      else:
21474 
        iprot.skip(ftype)
21475 
      iprot.readFieldEnd()
21476 
    iprot.readStructEnd()
21477 
 
21478 
  def write(self, oprot):
21479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21481 
      return
21482 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21483 
    if self.settlementId is not None:
21484 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21485 
      oprot.writeI64(self.settlementId)
21486 
      oprot.writeFieldEnd()
21487 
    oprot.writeFieldStop()
21488 
    oprot.writeStructEnd()
21489 
 
21490 
  def validate(self):
21491 
    return
21492 
 
21493 
 
21494 
  def __repr__(self):
21495 
    L = ['%s=%r' % (key, value)
21496 
      for key, value in self.__dict__.iteritems()]
21497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21498 
 
21499 
  def __eq__(self, other):
21500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21501 
 
21502 
  def __ne__(self, other):
21503 
    return not (self == other)
21504 
 
21505 
class getEBSSettlementDate_result:
21506 
  """
21507 
  Attributes:
21508 
   - success
21509 
   - ex
21510 
  """
21511 
 
21512 
  thrift_spec = (
21513 
    (0, TType.I64, 'success', None, None, ), # 0
21514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21515 
  )
21516 
 
21517 
  def __init__(self, success=None, ex=None,):
21518 
    self.success = success
21519 
    self.ex = ex
21520 
 
21521 
  def read(self, iprot):
21522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21524 
      return
21525 
    iprot.readStructBegin()
21526 
    while True:
21527 
      (fname, ftype, fid) = iprot.readFieldBegin()
21528 
      if ftype == TType.STOP:
21529 
        break
21530 
      if fid == 0:
21531 
        if ftype == TType.I64:
21532 
          self.success = iprot.readI64();
21533 
        else:
21534 
          iprot.skip(ftype)
21535 
      elif fid == 1:
21536 
        if ftype == TType.STRUCT:
21537 
          self.ex = TransactionServiceException()
21538 
          self.ex.read(iprot)
21539 
        else:
21540 
          iprot.skip(ftype)
21541 
      else:
21542 
        iprot.skip(ftype)
21543 
      iprot.readFieldEnd()
21544 
    iprot.readStructEnd()
21545 
 
21546 
  def write(self, oprot):
21547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21549 
      return
21550 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21551 
    if self.success is not None:
21552 
      oprot.writeFieldBegin('success', TType.I64, 0)
21553 
      oprot.writeI64(self.success)
21554 
      oprot.writeFieldEnd()
21555 
    if self.ex is not None:
21556 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21557 
      self.ex.write(oprot)
21558 
      oprot.writeFieldEnd()
21559 
    oprot.writeFieldStop()
21560 
    oprot.writeStructEnd()
21561 
 
21562 
  def validate(self):
21563 
    return
21564 
 
21565 
 
21566 
  def __repr__(self):
21567 
    L = ['%s=%r' % (key, value)
21568 
      for key, value in self.__dict__.iteritems()]
21569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21570 
 
21571 
  def __eq__(self, other):
21572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21573 
 
21574 
  def __ne__(self, other):
21575 
    return not (self == other)
4715 varun.gupt 21576 
 
21577 
class getSettlementsByDate_args:
21578 
  """
21579 
  Attributes:
21580 
   - settlementDateFrom
21581 
   - settlementDateTo
21582 
   - isRefund
21583 
  """
21584 
 
21585 
  thrift_spec = (
21586 
    None, # 0
21587 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21588 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21589 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21590 
  )
21591 
 
21592 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21593 
    self.settlementDateFrom = settlementDateFrom
21594 
    self.settlementDateTo = settlementDateTo
21595 
    self.isRefund = isRefund
21596 
 
21597 
  def read(self, iprot):
21598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21600 
      return
21601 
    iprot.readStructBegin()
21602 
    while True:
21603 
      (fname, ftype, fid) = iprot.readFieldBegin()
21604 
      if ftype == TType.STOP:
21605 
        break
21606 
      if fid == 1:
21607 
        if ftype == TType.I64:
21608 
          self.settlementDateFrom = iprot.readI64();
21609 
        else:
21610 
          iprot.skip(ftype)
21611 
      elif fid == 2:
21612 
        if ftype == TType.I64:
21613 
          self.settlementDateTo = iprot.readI64();
21614 
        else:
21615 
          iprot.skip(ftype)
21616 
      elif fid == 3:
21617 
        if ftype == TType.BOOL:
21618 
          self.isRefund = iprot.readBool();
21619 
        else:
21620 
          iprot.skip(ftype)
21621 
      else:
21622 
        iprot.skip(ftype)
21623 
      iprot.readFieldEnd()
21624 
    iprot.readStructEnd()
21625 
 
21626 
  def write(self, oprot):
21627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21629 
      return
21630 
    oprot.writeStructBegin('getSettlementsByDate_args')
21631 
    if self.settlementDateFrom is not None:
21632 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21633 
      oprot.writeI64(self.settlementDateFrom)
21634 
      oprot.writeFieldEnd()
21635 
    if self.settlementDateTo is not None:
21636 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21637 
      oprot.writeI64(self.settlementDateTo)
21638 
      oprot.writeFieldEnd()
21639 
    if self.isRefund is not None:
21640 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21641 
      oprot.writeBool(self.isRefund)
21642 
      oprot.writeFieldEnd()
21643 
    oprot.writeFieldStop()
21644 
    oprot.writeStructEnd()
21645 
 
21646 
  def validate(self):
21647 
    return
21648 
 
21649 
 
21650 
  def __repr__(self):
21651 
    L = ['%s=%r' % (key, value)
21652 
      for key, value in self.__dict__.iteritems()]
21653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21654 
 
21655 
  def __eq__(self, other):
21656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21657 
 
21658 
  def __ne__(self, other):
21659 
    return not (self == other)
21660 
 
21661 
class getSettlementsByDate_result:
21662 
  """
21663 
  Attributes:
21664 
   - success
21665 
   - ex
21666 
  """
21667 
 
21668 
  thrift_spec = (
21669 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21671 
  )
21672 
 
21673 
  def __init__(self, success=None, ex=None,):
21674 
    self.success = success
21675 
    self.ex = ex
21676 
 
21677 
  def read(self, iprot):
21678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21680 
      return
21681 
    iprot.readStructBegin()
21682 
    while True:
21683 
      (fname, ftype, fid) = iprot.readFieldBegin()
21684 
      if ftype == TType.STOP:
21685 
        break
21686 
      if fid == 0:
21687 
        if ftype == TType.LIST:
21688 
          self.success = []
5386 phani.kuma 21689 
          (_etype488, _size485) = iprot.readListBegin()
21690 
          for _i489 in xrange(_size485):
21691 
            _elem490 = PaymentSettlement()
21692 
            _elem490.read(iprot)
21693 
            self.success.append(_elem490)
4715 varun.gupt 21694 
          iprot.readListEnd()
21695 
        else:
21696 
          iprot.skip(ftype)
21697 
      elif fid == 1:
21698 
        if ftype == TType.STRUCT:
21699 
          self.ex = TransactionServiceException()
21700 
          self.ex.read(iprot)
21701 
        else:
21702 
          iprot.skip(ftype)
21703 
      else:
21704 
        iprot.skip(ftype)
21705 
      iprot.readFieldEnd()
21706 
    iprot.readStructEnd()
21707 
 
21708 
  def write(self, oprot):
21709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21711 
      return
21712 
    oprot.writeStructBegin('getSettlementsByDate_result')
21713 
    if self.success is not None:
21714 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21715 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 21716 
      for iter491 in self.success:
21717 
        iter491.write(oprot)
4715 varun.gupt 21718 
      oprot.writeListEnd()
21719 
      oprot.writeFieldEnd()
21720 
    if self.ex is not None:
21721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21722 
      self.ex.write(oprot)
21723 
      oprot.writeFieldEnd()
21724 
    oprot.writeFieldStop()
21725 
    oprot.writeStructEnd()
21726 
 
21727 
  def validate(self):
21728 
    return
21729 
 
21730 
 
21731 
  def __repr__(self):
21732 
    L = ['%s=%r' % (key, value)
21733 
      for key, value in self.__dict__.iteritems()]
21734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21735 
 
21736 
  def __eq__(self, other):
21737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21738 
 
21739 
  def __ne__(self, other):
21740 
    return not (self == other)
21741 
 
21742 
class getReshippedOrderIds_args:
21743 
  """
21744 
  Attributes:
21745 
   - orderIds
21746 
  """
21747 
 
21748 
  thrift_spec = (
21749 
    None, # 0
21750 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21751 
  )
21752 
 
21753 
  def __init__(self, orderIds=None,):
21754 
    self.orderIds = orderIds
21755 
 
21756 
  def read(self, iprot):
21757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21759 
      return
21760 
    iprot.readStructBegin()
21761 
    while True:
21762 
      (fname, ftype, fid) = iprot.readFieldBegin()
21763 
      if ftype == TType.STOP:
21764 
        break
21765 
      if fid == 1:
21766 
        if ftype == TType.LIST:
21767 
          self.orderIds = []
5386 phani.kuma 21768 
          (_etype495, _size492) = iprot.readListBegin()
21769 
          for _i496 in xrange(_size492):
21770 
            _elem497 = iprot.readI64();
21771 
            self.orderIds.append(_elem497)
4715 varun.gupt 21772 
          iprot.readListEnd()
21773 
        else:
21774 
          iprot.skip(ftype)
21775 
      else:
21776 
        iprot.skip(ftype)
21777 
      iprot.readFieldEnd()
21778 
    iprot.readStructEnd()
21779 
 
21780 
  def write(self, oprot):
21781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21783 
      return
21784 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21785 
    if self.orderIds is not None:
21786 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21787 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5386 phani.kuma 21788 
      for iter498 in self.orderIds:
21789 
        oprot.writeI64(iter498)
4715 varun.gupt 21790 
      oprot.writeListEnd()
21791 
      oprot.writeFieldEnd()
21792 
    oprot.writeFieldStop()
21793 
    oprot.writeStructEnd()
21794 
 
21795 
  def validate(self):
21796 
    return
21797 
 
21798 
 
21799 
  def __repr__(self):
21800 
    L = ['%s=%r' % (key, value)
21801 
      for key, value in self.__dict__.iteritems()]
21802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21803 
 
21804 
  def __eq__(self, other):
21805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21806 
 
21807 
  def __ne__(self, other):
21808 
    return not (self == other)
21809 
 
21810 
class getReshippedOrderIds_result:
21811 
  """
21812 
  Attributes:
21813 
   - success
21814 
   - ex
21815 
  """
21816 
 
21817 
  thrift_spec = (
21818 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21820 
  )
21821 
 
21822 
  def __init__(self, success=None, ex=None,):
21823 
    self.success = success
21824 
    self.ex = ex
21825 
 
21826 
  def read(self, iprot):
21827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21829 
      return
21830 
    iprot.readStructBegin()
21831 
    while True:
21832 
      (fname, ftype, fid) = iprot.readFieldBegin()
21833 
      if ftype == TType.STOP:
21834 
        break
21835 
      if fid == 0:
21836 
        if ftype == TType.LIST:
21837 
          self.success = []
5386 phani.kuma 21838 
          (_etype502, _size499) = iprot.readListBegin()
21839 
          for _i503 in xrange(_size499):
21840 
            _elem504 = iprot.readI64();
21841 
            self.success.append(_elem504)
4715 varun.gupt 21842 
          iprot.readListEnd()
21843 
        else:
21844 
          iprot.skip(ftype)
21845 
      elif fid == 1:
21846 
        if ftype == TType.STRUCT:
21847 
          self.ex = TransactionServiceException()
21848 
          self.ex.read(iprot)
21849 
        else:
21850 
          iprot.skip(ftype)
21851 
      else:
21852 
        iprot.skip(ftype)
21853 
      iprot.readFieldEnd()
21854 
    iprot.readStructEnd()
21855 
 
21856 
  def write(self, oprot):
21857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21859 
      return
21860 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21861 
    if self.success is not None:
21862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21863 
      oprot.writeListBegin(TType.I64, len(self.success))
5386 phani.kuma 21864 
      for iter505 in self.success:
21865 
        oprot.writeI64(iter505)
4715 varun.gupt 21866 
      oprot.writeListEnd()
21867 
      oprot.writeFieldEnd()
21868 
    if self.ex is not None:
21869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21870 
      self.ex.write(oprot)
21871 
      oprot.writeFieldEnd()
21872 
    oprot.writeFieldStop()
21873 
    oprot.writeStructEnd()
21874 
 
21875 
  def validate(self):
21876 
    return
21877 
 
21878 
 
21879 
  def __repr__(self):
21880 
    L = ['%s=%r' % (key, value)
21881 
      for key, value in self.__dict__.iteritems()]
21882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21883 
 
21884 
  def __eq__(self, other):
21885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21886 
 
21887 
  def __ne__(self, other):
21888 
    return not (self == other)
4757 mandeep.dh 21889 
 
4875 varun.gupt 21890 
class getOrdersWhereVendorNotPaid_args:
21891 
  """
21892 
  Attributes:
21893 
   - vendorId
21894 
  """
21895 
 
21896 
  thrift_spec = (
21897 
    None, # 0
21898 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21899 
  )
21900 
 
21901 
  def __init__(self, vendorId=None,):
21902 
    self.vendorId = vendorId
21903 
 
21904 
  def read(self, iprot):
21905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21907 
      return
21908 
    iprot.readStructBegin()
21909 
    while True:
21910 
      (fname, ftype, fid) = iprot.readFieldBegin()
21911 
      if ftype == TType.STOP:
21912 
        break
21913 
      if fid == 1:
21914 
        if ftype == TType.I64:
21915 
          self.vendorId = iprot.readI64();
21916 
        else:
21917 
          iprot.skip(ftype)
21918 
      else:
21919 
        iprot.skip(ftype)
21920 
      iprot.readFieldEnd()
21921 
    iprot.readStructEnd()
21922 
 
21923 
  def write(self, oprot):
21924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21926 
      return
21927 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21928 
    if self.vendorId is not None:
21929 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21930 
      oprot.writeI64(self.vendorId)
21931 
      oprot.writeFieldEnd()
21932 
    oprot.writeFieldStop()
21933 
    oprot.writeStructEnd()
21934 
 
21935 
  def validate(self):
21936 
    return
21937 
 
21938 
 
21939 
  def __repr__(self):
21940 
    L = ['%s=%r' % (key, value)
21941 
      for key, value in self.__dict__.iteritems()]
21942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21943 
 
21944 
  def __eq__(self, other):
21945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21946 
 
21947 
  def __ne__(self, other):
21948 
    return not (self == other)
21949 
 
21950 
class getOrdersWhereVendorNotPaid_result:
21951 
  """
21952 
  Attributes:
21953 
   - success
21954 
   - ex
21955 
  """
21956 
 
21957 
  thrift_spec = (
21958 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21960 
  )
21961 
 
21962 
  def __init__(self, success=None, ex=None,):
21963 
    self.success = success
21964 
    self.ex = ex
21965 
 
21966 
  def read(self, iprot):
21967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21969 
      return
21970 
    iprot.readStructBegin()
21971 
    while True:
21972 
      (fname, ftype, fid) = iprot.readFieldBegin()
21973 
      if ftype == TType.STOP:
21974 
        break
21975 
      if fid == 0:
21976 
        if ftype == TType.LIST:
21977 
          self.success = []
5386 phani.kuma 21978 
          (_etype509, _size506) = iprot.readListBegin()
21979 
          for _i510 in xrange(_size506):
21980 
            _elem511 = Order()
21981 
            _elem511.read(iprot)
21982 
            self.success.append(_elem511)
4875 varun.gupt 21983 
          iprot.readListEnd()
21984 
        else:
21985 
          iprot.skip(ftype)
21986 
      elif fid == 1:
21987 
        if ftype == TType.STRUCT:
21988 
          self.ex = TransactionServiceException()
21989 
          self.ex.read(iprot)
21990 
        else:
21991 
          iprot.skip(ftype)
21992 
      else:
21993 
        iprot.skip(ftype)
21994 
      iprot.readFieldEnd()
21995 
    iprot.readStructEnd()
21996 
 
21997 
  def write(self, oprot):
21998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22000 
      return
22001 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
22002 
    if self.success is not None:
22003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 22005 
      for iter512 in self.success:
22006 
        iter512.write(oprot)
4875 varun.gupt 22007 
      oprot.writeListEnd()
22008 
      oprot.writeFieldEnd()
22009 
    if self.ex is not None:
22010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22011 
      self.ex.write(oprot)
22012 
      oprot.writeFieldEnd()
22013 
    oprot.writeFieldStop()
22014 
    oprot.writeStructEnd()
22015 
 
22016 
  def validate(self):
22017 
    return
22018 
 
22019 
 
22020 
  def __repr__(self):
22021 
    L = ['%s=%r' % (key, value)
22022 
      for key, value in self.__dict__.iteritems()]
22023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22024 
 
22025 
  def __eq__(self, other):
22026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22027 
 
22028 
  def __ne__(self, other):
22029 
    return not (self == other)
5031 varun.gupt 22030 
 
22031 
class getStatusDistributionOfOrders_args:
22032 
  """
22033 
  Attributes:
22034 
   - startDate
22035 
   - endDate
22036 
  """
22037 
 
22038 
  thrift_spec = (
22039 
    None, # 0
22040 
    (1, TType.I64, 'startDate', None, None, ), # 1
22041 
    (2, TType.I64, 'endDate', None, None, ), # 2
22042 
  )
22043 
 
22044 
  def __init__(self, startDate=None, endDate=None,):
22045 
    self.startDate = startDate
22046 
    self.endDate = endDate
22047 
 
22048 
  def read(self, iprot):
22049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22051 
      return
22052 
    iprot.readStructBegin()
22053 
    while True:
22054 
      (fname, ftype, fid) = iprot.readFieldBegin()
22055 
      if ftype == TType.STOP:
22056 
        break
22057 
      if fid == 1:
22058 
        if ftype == TType.I64:
22059 
          self.startDate = iprot.readI64();
22060 
        else:
22061 
          iprot.skip(ftype)
22062 
      elif fid == 2:
22063 
        if ftype == TType.I64:
22064 
          self.endDate = iprot.readI64();
22065 
        else:
22066 
          iprot.skip(ftype)
22067 
      else:
22068 
        iprot.skip(ftype)
22069 
      iprot.readFieldEnd()
22070 
    iprot.readStructEnd()
22071 
 
22072 
  def write(self, oprot):
22073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22075 
      return
22076 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22077 
    if self.startDate is not None:
22078 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22079 
      oprot.writeI64(self.startDate)
22080 
      oprot.writeFieldEnd()
22081 
    if self.endDate is not None:
22082 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22083 
      oprot.writeI64(self.endDate)
22084 
      oprot.writeFieldEnd()
22085 
    oprot.writeFieldStop()
22086 
    oprot.writeStructEnd()
22087 
 
22088 
  def validate(self):
22089 
    return
22090 
 
22091 
 
22092 
  def __repr__(self):
22093 
    L = ['%s=%r' % (key, value)
22094 
      for key, value in self.__dict__.iteritems()]
22095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22096 
 
22097 
  def __eq__(self, other):
22098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22099 
 
22100 
  def __ne__(self, other):
22101 
    return not (self == other)
22102 
 
22103 
class getStatusDistributionOfOrders_result:
22104 
  """
22105 
  Attributes:
22106 
   - success
22107 
   - ex
22108 
  """
22109 
 
22110 
  thrift_spec = (
22111 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22113 
  )
22114 
 
22115 
  def __init__(self, success=None, ex=None,):
22116 
    self.success = success
22117 
    self.ex = ex
22118 
 
22119 
  def read(self, iprot):
22120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22122 
      return
22123 
    iprot.readStructBegin()
22124 
    while True:
22125 
      (fname, ftype, fid) = iprot.readFieldBegin()
22126 
      if ftype == TType.STOP:
22127 
        break
22128 
      if fid == 0:
22129 
        if ftype == TType.MAP:
22130 
          self.success = {}
5386 phani.kuma 22131 
          (_ktype514, _vtype515, _size513 ) = iprot.readMapBegin()
22132 
          for _i517 in xrange(_size513):
22133 
            _key518 = iprot.readI64();
22134 
            _val519 = iprot.readI64();
22135 
            self.success[_key518] = _val519
5031 varun.gupt 22136 
          iprot.readMapEnd()
22137 
        else:
22138 
          iprot.skip(ftype)
22139 
      elif fid == 1:
22140 
        if ftype == TType.STRUCT:
22141 
          self.ex = TransactionServiceException()
22142 
          self.ex.read(iprot)
22143 
        else:
22144 
          iprot.skip(ftype)
22145 
      else:
22146 
        iprot.skip(ftype)
22147 
      iprot.readFieldEnd()
22148 
    iprot.readStructEnd()
22149 
 
22150 
  def write(self, oprot):
22151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22153 
      return
22154 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22155 
    if self.success is not None:
22156 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22157 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5386 phani.kuma 22158 
      for kiter520,viter521 in self.success.items():
22159 
        oprot.writeI64(kiter520)
22160 
        oprot.writeI64(viter521)
5031 varun.gupt 22161 
      oprot.writeMapEnd()
22162 
      oprot.writeFieldEnd()
22163 
    if self.ex is not None:
22164 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22165 
      self.ex.write(oprot)
22166 
      oprot.writeFieldEnd()
22167 
    oprot.writeFieldStop()
22168 
    oprot.writeStructEnd()
22169 
 
22170 
  def validate(self):
22171 
    return
22172 
 
22173 
 
22174 
  def __repr__(self):
22175 
    L = ['%s=%r' % (key, value)
22176 
      for key, value in self.__dict__.iteritems()]
22177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22178 
 
22179 
  def __eq__(self, other):
22180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22181 
 
22182 
  def __ne__(self, other):
22183 
    return not (self == other)
5067 varun.gupt 22184 
 
22185 
class getOrderIdsForStatus_args:
22186 
  """
22187 
  Attributes:
22188 
   - status
22189 
   - startDatetime
22190 
   - endDatetime
22191 
  """
22192 
 
22193 
  thrift_spec = (
22194 
    None, # 0
22195 
    (1, TType.I64, 'status', None, None, ), # 1
22196 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22197 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22198 
  )
22199 
 
22200 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22201 
    self.status = status
22202 
    self.startDatetime = startDatetime
22203 
    self.endDatetime = endDatetime
22204 
 
22205 
  def read(self, iprot):
22206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22208 
      return
22209 
    iprot.readStructBegin()
22210 
    while True:
22211 
      (fname, ftype, fid) = iprot.readFieldBegin()
22212 
      if ftype == TType.STOP:
22213 
        break
22214 
      if fid == 1:
22215 
        if ftype == TType.I64:
22216 
          self.status = iprot.readI64();
22217 
        else:
22218 
          iprot.skip(ftype)
22219 
      elif fid == 2:
22220 
        if ftype == TType.I64:
22221 
          self.startDatetime = iprot.readI64();
22222 
        else:
22223 
          iprot.skip(ftype)
22224 
      elif fid == 3:
22225 
        if ftype == TType.I64:
22226 
          self.endDatetime = iprot.readI64();
22227 
        else:
22228 
          iprot.skip(ftype)
22229 
      else:
22230 
        iprot.skip(ftype)
22231 
      iprot.readFieldEnd()
22232 
    iprot.readStructEnd()
22233 
 
22234 
  def write(self, oprot):
22235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22237 
      return
22238 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22239 
    if self.status is not None:
22240 
      oprot.writeFieldBegin('status', TType.I64, 1)
22241 
      oprot.writeI64(self.status)
22242 
      oprot.writeFieldEnd()
22243 
    if self.startDatetime is not None:
22244 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22245 
      oprot.writeI64(self.startDatetime)
22246 
      oprot.writeFieldEnd()
22247 
    if self.endDatetime is not None:
22248 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22249 
      oprot.writeI64(self.endDatetime)
22250 
      oprot.writeFieldEnd()
22251 
    oprot.writeFieldStop()
22252 
    oprot.writeStructEnd()
22253 
 
22254 
  def validate(self):
22255 
    return
22256 
 
22257 
 
22258 
  def __repr__(self):
22259 
    L = ['%s=%r' % (key, value)
22260 
      for key, value in self.__dict__.iteritems()]
22261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22262 
 
22263 
  def __eq__(self, other):
22264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22265 
 
22266 
  def __ne__(self, other):
22267 
    return not (self == other)
22268 
 
22269 
class getOrderIdsForStatus_result:
22270 
  """
22271 
  Attributes:
22272 
   - success
22273 
   - ex
22274 
  """
22275 
 
22276 
  thrift_spec = (
22277 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22279 
  )
22280 
 
22281 
  def __init__(self, success=None, ex=None,):
22282 
    self.success = success
22283 
    self.ex = ex
22284 
 
22285 
  def read(self, iprot):
22286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22288 
      return
22289 
    iprot.readStructBegin()
22290 
    while True:
22291 
      (fname, ftype, fid) = iprot.readFieldBegin()
22292 
      if ftype == TType.STOP:
22293 
        break
22294 
      if fid == 0:
22295 
        if ftype == TType.LIST:
22296 
          self.success = []
5386 phani.kuma 22297 
          (_etype525, _size522) = iprot.readListBegin()
22298 
          for _i526 in xrange(_size522):
22299 
            _elem527 = iprot.readI64();
22300 
            self.success.append(_elem527)
5067 varun.gupt 22301 
          iprot.readListEnd()
22302 
        else:
22303 
          iprot.skip(ftype)
22304 
      elif fid == 1:
22305 
        if ftype == TType.STRUCT:
22306 
          self.ex = TransactionServiceException()
22307 
          self.ex.read(iprot)
22308 
        else:
22309 
          iprot.skip(ftype)
22310 
      else:
22311 
        iprot.skip(ftype)
22312 
      iprot.readFieldEnd()
22313 
    iprot.readStructEnd()
22314 
 
22315 
  def write(self, oprot):
22316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22318 
      return
22319 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22320 
    if self.success is not None:
22321 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22322 
      oprot.writeListBegin(TType.I64, len(self.success))
5386 phani.kuma 22323 
      for iter528 in self.success:
22324 
        oprot.writeI64(iter528)
5067 varun.gupt 22325 
      oprot.writeListEnd()
22326 
      oprot.writeFieldEnd()
22327 
    if self.ex is not None:
22328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22329 
      self.ex.write(oprot)
22330 
      oprot.writeFieldEnd()
22331 
    oprot.writeFieldStop()
22332 
    oprot.writeStructEnd()
22333 
 
22334 
  def validate(self):
22335 
    return
22336 
 
22337 
 
22338 
  def __repr__(self):
22339 
    L = ['%s=%r' % (key, value)
22340 
      for key, value in self.__dict__.iteritems()]
22341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22342 
 
22343 
  def __eq__(self, other):
22344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22345 
 
22346 
  def __ne__(self, other):
22347 
    return not (self == other)
5099 varun.gupt 22348 
 
5348 anupam.sin 22349 
class updateCODAgent_args:
22350 
  """
22351 
  Attributes:
22352 
   - agent
22353 
   - orderId
22354 
  """
22355 
 
22356 
  thrift_spec = (
22357 
    None, # 0
22358 
    (1, TType.STRING, 'agent', None, None, ), # 1
22359 
    (2, TType.I64, 'orderId', None, None, ), # 2
22360 
  )
22361 
 
22362 
  def __init__(self, agent=None, orderId=None,):
22363 
    self.agent = agent
22364 
    self.orderId = orderId
22365 
 
22366 
  def read(self, iprot):
22367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22369 
      return
22370 
    iprot.readStructBegin()
22371 
    while True:
22372 
      (fname, ftype, fid) = iprot.readFieldBegin()
22373 
      if ftype == TType.STOP:
22374 
        break
22375 
      if fid == 1:
22376 
        if ftype == TType.STRING:
22377 
          self.agent = iprot.readString();
22378 
        else:
22379 
          iprot.skip(ftype)
22380 
      elif fid == 2:
22381 
        if ftype == TType.I64:
22382 
          self.orderId = iprot.readI64();
22383 
        else:
22384 
          iprot.skip(ftype)
22385 
      else:
22386 
        iprot.skip(ftype)
22387 
      iprot.readFieldEnd()
22388 
    iprot.readStructEnd()
22389 
 
22390 
  def write(self, oprot):
22391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22393 
      return
22394 
    oprot.writeStructBegin('updateCODAgent_args')
22395 
    if self.agent is not None:
22396 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22397 
      oprot.writeString(self.agent)
22398 
      oprot.writeFieldEnd()
22399 
    if self.orderId is not None:
22400 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22401 
      oprot.writeI64(self.orderId)
22402 
      oprot.writeFieldEnd()
22403 
    oprot.writeFieldStop()
22404 
    oprot.writeStructEnd()
22405 
 
22406 
  def validate(self):
22407 
    return
22408 
 
22409 
 
22410 
  def __repr__(self):
22411 
    L = ['%s=%r' % (key, value)
22412 
      for key, value in self.__dict__.iteritems()]
22413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22414 
 
22415 
  def __eq__(self, other):
22416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22417 
 
22418 
  def __ne__(self, other):
22419 
    return not (self == other)
22420 
 
22421 
class updateCODAgent_result:
22422 
  """
22423 
  Attributes:
22424 
   - ex
22425 
  """
22426 
 
22427 
  thrift_spec = (
22428 
    None, # 0
22429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22430 
  )
22431 
 
22432 
  def __init__(self, ex=None,):
22433 
    self.ex = ex
22434 
 
22435 
  def read(self, iprot):
22436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22438 
      return
22439 
    iprot.readStructBegin()
22440 
    while True:
22441 
      (fname, ftype, fid) = iprot.readFieldBegin()
22442 
      if ftype == TType.STOP:
22443 
        break
22444 
      if fid == 1:
22445 
        if ftype == TType.STRUCT:
22446 
          self.ex = TransactionServiceException()
22447 
          self.ex.read(iprot)
22448 
        else:
22449 
          iprot.skip(ftype)
22450 
      else:
22451 
        iprot.skip(ftype)
22452 
      iprot.readFieldEnd()
22453 
    iprot.readStructEnd()
22454 
 
22455 
  def write(self, oprot):
22456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22458 
      return
22459 
    oprot.writeStructBegin('updateCODAgent_result')
22460 
    if self.ex is not None:
22461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22462 
      self.ex.write(oprot)
22463 
      oprot.writeFieldEnd()
22464 
    oprot.writeFieldStop()
22465 
    oprot.writeStructEnd()
22466 
 
22467 
  def validate(self):
22468 
    return
22469 
 
22470 
 
22471 
  def __repr__(self):
22472 
    L = ['%s=%r' % (key, value)
22473 
      for key, value in self.__dict__.iteritems()]
22474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22475 
 
22476 
  def __eq__(self, other):
22477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22478 
 
22479 
  def __ne__(self, other):
22480 
    return not (self == other)
22481 
 
5099 varun.gupt 22482 
class updateOrderAsPaidToVendor_args:
22483 
  """
22484 
  Attributes:
22485 
   - orderId
22486 
  """
22487 
 
22488 
  thrift_spec = (
22489 
    None, # 0
22490 
    (1, TType.I64, 'orderId', None, None, ), # 1
22491 
  )
22492 
 
22493 
  def __init__(self, orderId=None,):
22494 
    self.orderId = orderId
22495 
 
22496 
  def read(self, iprot):
22497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22499 
      return
22500 
    iprot.readStructBegin()
22501 
    while True:
22502 
      (fname, ftype, fid) = iprot.readFieldBegin()
22503 
      if ftype == TType.STOP:
22504 
        break
22505 
      if fid == 1:
22506 
        if ftype == TType.I64:
22507 
          self.orderId = iprot.readI64();
22508 
        else:
22509 
          iprot.skip(ftype)
22510 
      else:
22511 
        iprot.skip(ftype)
22512 
      iprot.readFieldEnd()
22513 
    iprot.readStructEnd()
22514 
 
22515 
  def write(self, oprot):
22516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22518 
      return
22519 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22520 
    if self.orderId is not None:
22521 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22522 
      oprot.writeI64(self.orderId)
22523 
      oprot.writeFieldEnd()
22524 
    oprot.writeFieldStop()
22525 
    oprot.writeStructEnd()
22526 
 
22527 
  def validate(self):
22528 
    return
22529 
 
22530 
 
22531 
  def __repr__(self):
22532 
    L = ['%s=%r' % (key, value)
22533 
      for key, value in self.__dict__.iteritems()]
22534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22535 
 
22536 
  def __eq__(self, other):
22537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22538 
 
22539 
  def __ne__(self, other):
22540 
    return not (self == other)
22541 
 
22542 
class updateOrderAsPaidToVendor_result:
22543 
  """
22544 
  Attributes:
22545 
   - ex
22546 
  """
22547 
 
22548 
  thrift_spec = (
22549 
    None, # 0
22550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22551 
  )
22552 
 
22553 
  def __init__(self, ex=None,):
22554 
    self.ex = ex
22555 
 
22556 
  def read(self, iprot):
22557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22559 
      return
22560 
    iprot.readStructBegin()
22561 
    while True:
22562 
      (fname, ftype, fid) = iprot.readFieldBegin()
22563 
      if ftype == TType.STOP:
22564 
        break
22565 
      if fid == 1:
22566 
        if ftype == TType.STRUCT:
22567 
          self.ex = TransactionServiceException()
22568 
          self.ex.read(iprot)
22569 
        else:
22570 
          iprot.skip(ftype)
22571 
      else:
22572 
        iprot.skip(ftype)
22573 
      iprot.readFieldEnd()
22574 
    iprot.readStructEnd()
22575 
 
22576 
  def write(self, oprot):
22577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22579 
      return
22580 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22581 
    if self.ex is not None:
22582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22583 
      self.ex.write(oprot)
22584 
      oprot.writeFieldEnd()
22585 
    oprot.writeFieldStop()
22586 
    oprot.writeStructEnd()
22587 
 
22588 
  def validate(self):
22589 
    return
22590 
 
22591 
 
22592 
  def __repr__(self):
22593 
    L = ['%s=%r' % (key, value)
22594 
      for key, value in self.__dict__.iteritems()]
22595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22596 
 
22597 
  def __eq__(self, other):
22598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22599 
 
22600 
  def __ne__(self, other):
22601 
    return not (self == other)
5208 varun.gupt 22602 
 
5386 phani.kuma 22603 
class updateOrderOnlyAsPaidToVendor_args:
22604 
  """
22605 
  Attributes:
22606 
   - orderId
22607 
  """
22608 
 
22609 
  thrift_spec = (
22610 
    None, # 0
22611 
    (1, TType.I64, 'orderId', None, None, ), # 1
22612 
  )
22613 
 
22614 
  def __init__(self, orderId=None,):
22615 
    self.orderId = orderId
22616 
 
22617 
  def read(self, iprot):
22618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22620 
      return
22621 
    iprot.readStructBegin()
22622 
    while True:
22623 
      (fname, ftype, fid) = iprot.readFieldBegin()
22624 
      if ftype == TType.STOP:
22625 
        break
22626 
      if fid == 1:
22627 
        if ftype == TType.I64:
22628 
          self.orderId = iprot.readI64();
22629 
        else:
22630 
          iprot.skip(ftype)
22631 
      else:
22632 
        iprot.skip(ftype)
22633 
      iprot.readFieldEnd()
22634 
    iprot.readStructEnd()
22635 
 
22636 
  def write(self, oprot):
22637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22639 
      return
22640 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
22641 
    if self.orderId is not None:
22642 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22643 
      oprot.writeI64(self.orderId)
22644 
      oprot.writeFieldEnd()
22645 
    oprot.writeFieldStop()
22646 
    oprot.writeStructEnd()
22647 
 
22648 
  def validate(self):
22649 
    return
22650 
 
22651 
 
22652 
  def __repr__(self):
22653 
    L = ['%s=%r' % (key, value)
22654 
      for key, value in self.__dict__.iteritems()]
22655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22656 
 
22657 
  def __eq__(self, other):
22658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22659 
 
22660 
  def __ne__(self, other):
22661 
    return not (self == other)
22662 
 
22663 
class updateOrderOnlyAsPaidToVendor_result:
22664 
  """
22665 
  Attributes:
22666 
   - ex
22667 
  """
22668 
 
22669 
  thrift_spec = (
22670 
    None, # 0
22671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22672 
  )
22673 
 
22674 
  def __init__(self, ex=None,):
22675 
    self.ex = ex
22676 
 
22677 
  def read(self, iprot):
22678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22680 
      return
22681 
    iprot.readStructBegin()
22682 
    while True:
22683 
      (fname, ftype, fid) = iprot.readFieldBegin()
22684 
      if ftype == TType.STOP:
22685 
        break
22686 
      if fid == 1:
22687 
        if ftype == TType.STRUCT:
22688 
          self.ex = TransactionServiceException()
22689 
          self.ex.read(iprot)
22690 
        else:
22691 
          iprot.skip(ftype)
22692 
      else:
22693 
        iprot.skip(ftype)
22694 
      iprot.readFieldEnd()
22695 
    iprot.readStructEnd()
22696 
 
22697 
  def write(self, oprot):
22698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22700 
      return
22701 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
22702 
    if self.ex is not None:
22703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22704 
      self.ex.write(oprot)
22705 
      oprot.writeFieldEnd()
22706 
    oprot.writeFieldStop()
22707 
    oprot.writeStructEnd()
22708 
 
22709 
  def validate(self):
22710 
    return
22711 
 
22712 
 
22713 
  def __repr__(self):
22714 
    L = ['%s=%r' % (key, value)
22715 
      for key, value in self.__dict__.iteritems()]
22716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22717 
 
22718 
  def __eq__(self, other):
22719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22720 
 
22721 
  def __ne__(self, other):
22722 
    return not (self == other)
22723 
 
5208 varun.gupt 22724 
class getRefundedOrdersMarkedPaid_args:
22725 
 
22726 
  thrift_spec = (
22727 
  )
22728 
 
22729 
  def read(self, iprot):
22730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22732 
      return
22733 
    iprot.readStructBegin()
22734 
    while True:
22735 
      (fname, ftype, fid) = iprot.readFieldBegin()
22736 
      if ftype == TType.STOP:
22737 
        break
22738 
      else:
22739 
        iprot.skip(ftype)
22740 
      iprot.readFieldEnd()
22741 
    iprot.readStructEnd()
22742 
 
22743 
  def write(self, oprot):
22744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22746 
      return
22747 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22748 
    oprot.writeFieldStop()
22749 
    oprot.writeStructEnd()
22750 
 
22751 
  def validate(self):
22752 
    return
22753 
 
22754 
 
22755 
  def __repr__(self):
22756 
    L = ['%s=%r' % (key, value)
22757 
      for key, value in self.__dict__.iteritems()]
22758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22759 
 
22760 
  def __eq__(self, other):
22761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22762 
 
22763 
  def __ne__(self, other):
22764 
    return not (self == other)
22765 
 
22766 
class getRefundedOrdersMarkedPaid_result:
22767 
  """
22768 
  Attributes:
22769 
   - success
22770 
   - ex
22771 
  """
22772 
 
22773 
  thrift_spec = (
22774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22776 
  )
22777 
 
22778 
  def __init__(self, success=None, ex=None,):
22779 
    self.success = success
22780 
    self.ex = ex
22781 
 
22782 
  def read(self, iprot):
22783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22785 
      return
22786 
    iprot.readStructBegin()
22787 
    while True:
22788 
      (fname, ftype, fid) = iprot.readFieldBegin()
22789 
      if ftype == TType.STOP:
22790 
        break
22791 
      if fid == 0:
22792 
        if ftype == TType.LIST:
22793 
          self.success = []
5386 phani.kuma 22794 
          (_etype532, _size529) = iprot.readListBegin()
22795 
          for _i533 in xrange(_size529):
22796 
            _elem534 = Order()
22797 
            _elem534.read(iprot)
22798 
            self.success.append(_elem534)
5208 varun.gupt 22799 
          iprot.readListEnd()
22800 
        else:
22801 
          iprot.skip(ftype)
22802 
      elif fid == 1:
22803 
        if ftype == TType.STRUCT:
22804 
          self.ex = TransactionServiceException()
22805 
          self.ex.read(iprot)
22806 
        else:
22807 
          iprot.skip(ftype)
22808 
      else:
22809 
        iprot.skip(ftype)
22810 
      iprot.readFieldEnd()
22811 
    iprot.readStructEnd()
22812 
 
22813 
  def write(self, oprot):
22814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22816 
      return
22817 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22818 
    if self.success is not None:
22819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 22821 
      for iter535 in self.success:
22822 
        iter535.write(oprot)
5208 varun.gupt 22823 
      oprot.writeListEnd()
22824 
      oprot.writeFieldEnd()
22825 
    if self.ex is not None:
22826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22827 
      self.ex.write(oprot)
22828 
      oprot.writeFieldEnd()
22829 
    oprot.writeFieldStop()
22830 
    oprot.writeStructEnd()
22831 
 
22832 
  def validate(self):
22833 
    return
22834 
 
22835 
 
22836 
  def __repr__(self):
22837 
    L = ['%s=%r' % (key, value)
22838 
      for key, value in self.__dict__.iteritems()]
22839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22840 
 
22841 
  def __eq__(self, other):
22842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22843 
 
22844 
  def __ne__(self, other):
22845 
    return not (self == other)