Subversion Repositories SmartDukaan

Rev

Rev 5387 | Rev 5447 | 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 
 
5387 rajveer 58 
  def changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5387 rajveer 64 
     - selfPickup
94 ashish 65 
    """
66 
    pass
67 
 
1398 varun.gupt 68 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 69 
    """
70 
    Parameters:
71 
     - transactionId
72 
    """
73 
    pass
74 
 
4801 anupam.sin 75 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 76 
    """
77 
    Parameters:
4801 anupam.sin 78 
     - statuses
483 rajveer 79 
     - from_date
80 
     - to_date
81 
     - warehouse_id
94 ashish 82 
    """
83 
    pass
84 
 
4133 chandransh 85 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
86 
    """
87 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
88 
    Pass the status as null and the limit as 0 to ignore them.
89 
 
90 
    Parameters:
91 
     - statuses
92 
     - offset
93 
     - limit
94 
     - warehouse_id
95 
    """
96 
    pass
97 
 
98 
  def getOrderCount(self, statuses, warehouseId):
99 
    """
100 
    Returns the count of orders with the given statuses assigned to the given warehouse.
101 
 
102 
    Parameters:
103 
     - statuses
104 
     - warehouseId
105 
    """
106 
    pass
107 
 
999 varun.gupt 108 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
109 
    """
1132 chandransh 110 
    Returns orders within a range of their billing dates
3431 rajveer 111 
 
999 varun.gupt 112 
    Parameters:
113 
     - status
114 
     - start_billing_date
115 
     - end_billing_date
116 
     - warehouse_id
117 
    """
118 
    pass
119 
 
3451 chandransh 120 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 121 
    """
122 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 123 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
124 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 125 
 
3427 chandransh 126 
    Parameters:
127 
     - fromShippingDate
128 
     - toShippingDate
129 
     - providerId
130 
     - warehouseId
3451 chandransh 131 
     - cod
3427 chandransh 132 
    """
133 
    pass
134 
 
1382 varun.gupt 135 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
136 
    """
137 
    Returns order ids for orders which can be returned
3431 rajveer 138 
 
1382 varun.gupt 139 
    Parameters:
140 
     - customer_id
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
146 
    """
147 
    Returns order ids for orders which can be cancelled
3431 rajveer 148 
 
1382 varun.gupt 149 
    Parameters:
150 
     - customer_id
151 
     - limit
152 
    """
153 
    pass
154 
 
483 rajveer 155 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 156 
    """
157 
    Parameters:
483 rajveer 158 
     - orderId
159 
     - status
160 
     - description
94 ashish 161 
    """
162 
    pass
163 
 
1528 ankur.sing 164 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 165 
    """
1528 ankur.sing 166 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
167 
    only user who owns the transaction can view its order details.
3431 rajveer 168 
 
94 ashish 169 
    Parameters:
170 
     - transactionId
1528 ankur.sing 171 
     - customerId
94 ashish 172 
    """
173 
    pass
174 
 
3014 chandransh 175 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 176 
    """
3014 chandransh 177 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
178 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 179 
 
94 ashish 180 
    Parameters:
483 rajveer 181 
     - customerId
182 
     - from_date
183 
     - to_date
3014 chandransh 184 
     - statuses
94 ashish 185 
    """
186 
    pass
187 
 
483 rajveer 188 
  def createOrder(self, order):
94 ashish 189 
    """
190 
    Parameters:
483 rajveer 191 
     - order
94 ashish 192 
    """
193 
    pass
194 
 
483 rajveer 195 
  def getOrder(self, id):
94 ashish 196 
    """
197 
    Parameters:
483 rajveer 198 
     - id
94 ashish 199 
    """
200 
    pass
201 
 
483 rajveer 202 
  def getLineItemsForOrder(self, orderId):
94 ashish 203 
    """
204 
    Parameters:
483 rajveer 205 
     - orderId
94 ashish 206 
    """
207 
    pass
208 
 
4999 phani.kuma 209 
  def getOrderList(self, order_ids):
210 
    """
211 
    Parameters:
212 
     - order_ids
213 
    """
214 
    pass
215 
 
5386 phani.kuma 216 
  def getOrderListForVendor(self, order_ids, vendorId):
217 
    """
218 
    Parameters:
219 
     - order_ids
220 
     - vendorId
221 
    """
222 
    pass
223 
 
1528 ankur.sing 224 
  def getOrderForCustomer(self, orderId, customerId):
225 
    """
226 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
227 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 228 
 
1528 ankur.sing 229 
    Parameters:
230 
     - orderId
231 
     - customerId
232 
    """
233 
    pass
234 
 
4444 rajveer 235 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 236 
    """
237 
    Parameters:
4394 rajveer 238 
     - type
4444 rajveer 239 
     - warehouseId
4394 rajveer 240 
     - status
241 
     - timestamp
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 246 
    """
247 
    Parameters:
248 
     - type
4444 rajveer 249 
     - warehouseId
4394 rajveer 250 
     - description
3064 chandransh 251 
    """
252 
    pass
253 
 
4444 rajveer 254 
  def markAlertsAsSeen(self, warehouseId):
255 
    """
256 
    Parameters:
257 
     - warehouseId
258 
    """
259 
    pass
260 
 
3064 chandransh 261 
  def getValidOrderCount(self, ):
262 
    """
263 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
264 
    """
265 
    pass
266 
 
267 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
268 
    """
269 
    Returns the number of distinct customers who have done successful transactions
270 
    """
271 
    pass
272 
 
273 
  def getValidOrdersAmountRange(self, ):
274 
    """
275 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
276 
    List contains two values, first minimum amount and second maximum amount.
277 
    """
278 
    pass
279 
 
280 
  def getValidOrders(self, limit):
281 
    """
282 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
283 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 284 
 
3064 chandransh 285 
    Parameters:
286 
     - limit
287 
    """
288 
    pass
289 
 
1220 chandransh 290 
  def batchOrders(self, warehouseId):
291 
    """
292 
    Create a batch of all the pending orders for the given warehouse.
293 
    The returned list is orderd by created_timestamp.
294 
    If there are no pending orders, an empty list is returned.
3431 rajveer 295 
 
1220 chandransh 296 
    Parameters:
297 
     - warehouseId
298 
    """
299 
    pass
300 
 
1208 chandransh 301 
  def markOrderAsOutOfStock(self, orderId):
302 
    """
303 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 304 
 
1208 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
3064 chandransh 310 
  def verifyOrder(self, orderId):
759 chandransh 311 
    """
3064 chandransh 312 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
313 
    timestamp. It is intended to be used for COD orders but can be harmlessly
314 
    used for all other orders as well.
315 
    Throws an exception if no such order exists.
3431 rajveer 316 
 
759 chandransh 317 
    Parameters:
3064 chandransh 318 
     - orderId
319 
    """
320 
    pass
321 
 
322 
  def acceptOrder(self, orderId):
323 
    """
324 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
325 
    given order is not a COD order, it also captures the payment if the same has
326 
    not been captured.
327 
    Throws an exception if no such order exists.
3431 rajveer 328 
 
3064 chandransh 329 
    Parameters:
330 
     - orderId
331 
    """
332 
    pass
333 
 
5110 mandeep.dh 334 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 335 
    """
336 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 337 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 338 
    the IMEI no. if a -1 is supplied.
339 
    Also, it generates an invoice number for the order, marks the order as
340 
    BILLED and sets the billing timestamp.
341 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 342 
 
3064 chandransh 343 
    Parameters:
344 
     - orderId
4283 anupam.sin 345 
     - invoice_number
4658 mandeep.dh 346 
     - serialNumber
3064 chandransh 347 
     - itemNumber
4283 anupam.sin 348 
     - billed_by
349 
     - jacketNumber
3064 chandransh 350 
     - billingType
5110 mandeep.dh 351 
     - fulfilmentWarehouseId
4763 rajveer 352 
     - authorize
3064 chandransh 353 
    """
354 
    pass
355 
 
4763 rajveer 356 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 357 
    """
358 
    Add the invoice number to the order.
359 
 
360 
    Parameters:
361 
     - orderId
362 
     - invoiceNumber
4763 rajveer 363 
     - color
4579 rajveer 364 
    """
365 
    pass
366 
 
4910 phani.kuma 367 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 368 
    """
369 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 370 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 371 
 
372 
    Parameters:
373 
     - warehouseId
374 
     - providerId
375 
     - cod
4910 phani.kuma 376 
     - orderIds
4410 rajveer 377 
    """
378 
    pass
379 
 
4910 phani.kuma 380 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 381 
    """
4910 phani.kuma 382 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
383 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 384 
 
3064 chandransh 385 
    Parameters:
759 chandransh 386 
     - providerId
4910 phani.kuma 387 
     - pickupDetails
759 chandransh 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 392 
    """
393 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 394 
 
1113 chandransh 395 
    Parameters:
396 
     - providerId
397 
    """
398 
    pass
399 
 
1132 chandransh 400 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
401 
    """
402 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
403 
    the name of the receiver.
404 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 405 
 
1132 chandransh 406 
    Parameters:
407 
     - providerId
408 
     - deliveredOrders
409 
    """
410 
    pass
411 
 
4910 phani.kuma 412 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 413 
    """
4910 phani.kuma 414 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1135 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - returnedOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def getRTOrders(self, providerId):
424 
    """
425 
    Returns a list of orders that were returned by courier.
426 
 
427 
    Parameters:
428 
     - providerId
429 
    """
430 
    pass
431 
 
1246 chandransh 432 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
433 
    """
434 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 435 
 
1246 chandransh 436 
    Parameters:
437 
     - providerId
438 
     - undeliveredOrders
439 
    """
440 
    pass
441 
 
4910 phani.kuma 442 
  def getNonDeliveredOrdersbyCourier(self, providerId):
443 
    """
444 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
445 
 
446 
    Parameters:
447 
     - providerId
448 
    """
449 
    pass
450 
 
451 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
452 
    """
453 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
454 
 
455 
    Parameters:
456 
     - providerId
457 
     - local_connected_orders
458 
    """
459 
    pass
460 
 
461 
  def getOrdersNotLocalConnected(self, providerId):
462 
    """
463 
    Returns a list of orders that were picked up or shipped but pending local connection.
464 
 
465 
    Parameters:
466 
     - providerId
467 
    """
468 
    pass
469 
 
470 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
471 
    """
472 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
473 
 
474 
    Parameters:
475 
     - providerId
476 
     - destination_city_reached_orders
477 
    """
478 
    pass
479 
 
480 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
481 
    """
482 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
483 
 
484 
    Parameters:
485 
     - providerId
486 
     - first_atdl_orders
487 
    """
488 
    pass
489 
 
1408 ankur.sing 490 
  def getUndeliveredOrders(self, providerId, warehouseId):
491 
    """
492 
    Returns the list of orders whose delivery time has passed but have not been
493 
    delivered yet for the given provider and warehouse. To get a complete list of
494 
    undelivered orders, pass them as -1.
495 
    Returns an empty list if no such orders exist.
3431 rajveer 496 
 
1408 ankur.sing 497 
    Parameters:
498 
     - providerId
499 
     - warehouseId
500 
    """
501 
    pass
502 
 
4783 phani.kuma 503 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
504 
    """
505 
    Returns the list of orders whose expected delivery date has passed but have not been
506 
    delivered yet.
507 
    Returns an empty list if no such orders exist.
508 
    """
509 
    pass
510 
 
2536 chandransh 511 
  def toggleDOAFlag(self, orderId):
512 
    """
513 
    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.
514 
    Returns the final flag status.
515 
    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 516 
 
2536 chandransh 517 
    Parameters:
518 
     - orderId
519 
    """
520 
    pass
1886 ankur.sing 521 
 
4712 rajveer 522 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
523 
    """
524 
    Parameters:
525 
     - orderId
526 
     - deliveryTimestamp
527 
     - receiver
528 
    """
529 
    pass
530 
 
4454 rajveer 531 
  def markOrderDoaRequestReceived(self, orderId):
532 
    """
533 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
534 
 
535 
    Parameters:
536 
     - orderId
537 
    """
538 
    pass
539 
 
540 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
541 
    """
542 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
543 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
544 
 
545 
    Parameters:
546 
     - orderId
547 
     - isAuthorized
548 
    """
549 
    pass
550 
 
4488 rajveer 551 
  def markOrderReturnRequestReceived(self, orderId):
552 
    """
553 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
554 
 
555 
    Parameters:
556 
     - orderId
557 
    """
558 
    pass
559 
 
560 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
561 
    """
562 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
563 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
564 
 
565 
    Parameters:
566 
     - orderId
567 
     - isAuthorized
568 
    """
569 
    pass
570 
 
4579 rajveer 571 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 572 
    """
573 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 574 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
575 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 576 
    For any other status, it returns false.
577 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 578 
 
2536 chandransh 579 
    Parameters:
580 
     - orderId
4579 rajveer 581 
     - providerId
2536 chandransh 582 
    """
583 
    pass
584 
 
4602 rajveer 585 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 586 
    """
4452 rajveer 587 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 588 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
589 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
590 
    	3. Returns true
2591 chandransh 591 
    If the order is in any other status, it returns false.
2536 chandransh 592 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 593 
 
2536 chandransh 594 
    Parameters:
595 
     - orderId
596 
     - pickupNumber
4602 rajveer 597 
     - providerId
2536 chandransh 598 
    """
599 
    pass
600 
 
2764 chandransh 601 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
602 
    """
603 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 604 
 
2764 chandransh 605 
    Parameters:
606 
     - providerId
607 
     - pickupDetails
608 
    """
609 
    pass
610 
 
4910 phani.kuma 611 
  def getDoasNotPickedUp(self, providerId):
612 
    """
613 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
614 
 
615 
    Parameters:
616 
     - providerId
617 
    """
618 
    pass
619 
 
4741 phani.kuma 620 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
623 
 
624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getReturnOrdersNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4479 rajveer 639 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 640 
    """
4452 rajveer 641 
    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 642 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 643 
    If the order is in any other state, it returns false.
644 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 645 
 
2591 chandransh 646 
    Parameters:
647 
     - orderId
4479 rajveer 648 
     - receiveCondition
2591 chandransh 649 
    """
650 
    pass
2536 chandransh 651 
 
2591 chandransh 652 
  def validateDoa(self, orderId, isValid):
653 
    """
4452 rajveer 654 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 655 
    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 656 
    If the order is in any other state, it returns false.
657 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 658 
 
2591 chandransh 659 
    Parameters:
660 
     - orderId
661 
     - isValid
662 
    """
663 
    pass
664 
 
4495 rajveer 665 
  def validateReturnProduct(self, orderId, isUsable):
666 
    """
667 
    Parameters:
668 
     - orderId
669 
     - isUsable
670 
    """
671 
    pass
672 
 
2616 chandransh 673 
  def reshipOrder(self, orderId):
674 
    """
4484 rajveer 675 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 676 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 677 
    	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 678 
 
679 
    If the order is in DOA_CERT_VALID state, it does the following:
680 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
681 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 682 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 683 
 
2616 chandransh 684 
    Returns the id of the newly created order.
3431 rajveer 685 
 
2616 chandransh 686 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 687 
 
2616 chandransh 688 
    Parameters:
689 
     - orderId
690 
    """
691 
    pass
2591 chandransh 692 
 
3226 chandransh 693 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 694 
    """
4484 rajveer 695 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 696 
    	1. Creates a refund request for batch processing.
697 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 698 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 699 
 
2616 chandransh 700 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
701 
    	1. Creates a refund request for batch processing.
3226 chandransh 702 
    	2. Cancels the reservation of the item in the warehouse.
703 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 704 
 
3226 chandransh 705 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
706 
    	1. Cancels the reservation of the item in the warehouse.
707 
    	2. Marks the current order as CANCELED.
708 
 
709 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
710 
 
2616 chandransh 711 
    Returns True if it is successful, False otherwise.
3431 rajveer 712 
 
2616 chandransh 713 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 714 
 
2616 chandransh 715 
    Parameters:
716 
     - orderId
3226 chandransh 717 
     - refundedBy
718 
     - reason
2616 chandransh 719 
    """
720 
    pass
721 
 
2690 chandransh 722 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
723 
    """
724 
    Get all return orders created between the from and to dates for the given warehouse.
725 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 726 
 
2690 chandransh 727 
    Parameters:
728 
     - warehouseId
729 
     - fromDate
730 
     - toDate
731 
    """
732 
    pass
2616 chandransh 733 
 
2700 chandransh 734 
  def getReturnOrder(self, id):
735 
    """
736 
    Returns the ReturnOrder corresponding to the given id.
737 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 738 
 
2700 chandransh 739 
    Parameters:
740 
     - id
741 
    """
742 
    pass
743 
 
2690 chandransh 744 
  def processReturn(self, returnOrderId):
745 
    """
746 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - returnOrderId
750 
    """
751 
    pass
752 
 
3451 chandransh 753 
  def updateWeight(self, orderId, weight):
754 
    """
755 
    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 756 
 
3451 chandransh 757 
    Parameters:
758 
     - orderId
759 
     - weight
760 
    """
761 
    pass
762 
 
3469 chandransh 763 
  def changeItem(self, orderId, itemId):
764 
    """
765 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
766 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 767 
 
3469 chandransh 768 
    Parameters:
769 
     - orderId
770 
     - itemId
771 
    """
772 
    pass
773 
 
774 
  def shiftToWarehouse(self, orderId, warehouseId):
775 
    """
776 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
777 
 
778 
    Parameters:
779 
     - orderId
780 
     - warehouseId
781 
    """
782 
    pass
783 
 
4647 rajveer 784 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 785 
    """
786 
    Adds the given delay reason to the given order.
3986 chandransh 787 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 788 
    Raises an exception if no order with the given id can be found.
3469 chandransh 789 
 
3553 chandransh 790 
    Parameters:
791 
     - orderId
792 
     - delayReason
3986 chandransh 793 
     - furtherDelay
4647 rajveer 794 
     - delayReasonText
3553 chandransh 795 
    """
796 
    pass
797 
 
3956 chandransh 798 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
799 
    """
800 
    Marks the COD orders with given AWB nos. as having been processed.
801 
    Updates the captured amount for the corresponding payment.
3553 chandransh 802 
 
3956 chandransh 803 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
804 
    1. There is no order corresponding to an AWB number.
805 
    2. The captured amount for a payment exceeds the total payment.
806 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
807 
 
808 
    Parameters:
809 
     - collectedAmountMap
810 
     - xferBy
811 
     - xferTxnId
812 
     - xferDate
813 
    """
814 
    pass
815 
 
4008 mandeep.dh 816 
  def getTransactionsRequiringExtraProcessing(self, category):
817 
    """
4065 mandeep.dh 818 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 819 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 820 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 821 
 
4008 mandeep.dh 822 
    Parameters:
823 
     - category
824 
    """
825 
    pass
826 
 
827 
  def markTransactionAsProcessed(self, transactionId, category):
828 
    """
829 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 830 
    It essentially deletes the transaction id record for a particular
831 
    processing type category (if present) from DB.
832 
    This is currently used by CRM application.
4008 mandeep.dh 833 
 
834 
    Parameters:
835 
     - transactionId
836 
     - category
837 
    """
838 
    pass
839 
 
4018 chandransh 840 
  def getItemWiseRiskyOrdersCount(self, ):
841 
    """
842 
    Returns a map containing the number of risky orders keyed by item id. A risky order
843 
    is defined as one whose shipping date is about to expire.
844 
    """
845 
    pass
4008 mandeep.dh 846 
 
4295 varun.gupt 847 
  def getOrdersForItemIds(self, itemIds):
848 
    """
849 
    Returns a list of all orders which have items with given id
850 
 
851 
    Parameters:
852 
     - itemIds
853 
    """
854 
    pass
855 
 
4247 rajveer 856 
  def markOrderCancellationRequestReceived(self, orderId):
857 
    """
858 
    Mark order as cancellation request received. If customer sends request of cancellation of
859 
    a particular order, this method will be called. It will just change status of the order
860 
    depending on its current status. It also records the previous status, so that we can move
861 
    back to that status if cancellation request is denied.
4018 chandransh 862 
 
4247 rajveer 863 
    Parameters:
864 
     - orderId
865 
    """
866 
    pass
867 
 
868 
  def markOrderCancellationRequestConfirmed(self, orderId):
869 
    """
870 
    If we decide to to cancel order, CRM will call this method to move the status of order to
871 
    cancellation request confirmed. After this OM will be able to cancel the order.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
878 
  def markOrderCancellationRequestDenied(self, orderId):
879 
    """
880 
    If we decide to not to cancel order, we will move the order ro previous status.
881 
 
882 
    Parameters:
883 
     - orderId
884 
    """
885 
    pass
886 
 
4258 rajveer 887 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 888 
    """
4258 rajveer 889 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
890 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 891 
 
892 
    Parameters:
4258 rajveer 893 
     - transactionId
4247 rajveer 894 
    """
895 
    pass
896 
 
4259 anupam.sin 897 
  def refundTransaction(self, transactionId, refundedBy, reason):
898 
    """
899 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
900 
    need to be cancelled
4247 rajveer 901 
 
4259 anupam.sin 902 
    Parameters:
903 
     - transactionId
904 
     - refundedBy
905 
     - reason
906 
    """
907 
    pass
908 
 
4324 mandeep.dh 909 
  def updateShipmentAddress(self, orderId, addressId):
910 
    """
911 
    Updates shipment address of an order. Delivery and shipping date estimates
912 
    etc. are also updated here.
913 
 
914 
    Throws TransactionServiceException in case address change is not
915 
    possible due to certain reasons such as new pincode in address is
916 
    not serviceable etc.
917 
 
918 
    Parameters:
919 
     - orderId
920 
     - addressId
921 
    """
922 
    pass
923 
 
4285 rajveer 924 
  def acceptOrdersForItemId(self, itemId, inventory):
925 
    """
926 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
927 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 928 
 
4285 rajveer 929 
    Parameters:
930 
     - itemId
931 
     - inventory
932 
    """
933 
    pass
934 
 
4369 rajveer 935 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 936 
    """
937 
    Parameters:
938 
     - vendorId
939 
     - itemId
940 
     - quantity
941 
     - estimate
4369 rajveer 942 
     - isReminder
4303 rajveer 943 
    """
944 
    pass
4285 rajveer 945 
 
4369 rajveer 946 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 947 
    """
948 
    Parameters:
949 
     - vendorId
950 
     - itemId
951 
     - quantity
952 
     - estimate
4369 rajveer 953 
     - isReminder
4303 rajveer 954 
    """
955 
    pass
956 
 
4369 rajveer 957 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 958 
    """
959 
    Parameters:
960 
     - vendorId
961 
     - itemId
962 
     - quantity
963 
     - estimate
4369 rajveer 964 
     - isReminder
4303 rajveer 965 
    """
966 
    pass
967 
 
4369 rajveer 968 
  def markOrdersAsTimeout(self, vendorId):
969 
    """
970 
    Parameters:
971 
     - vendorId
972 
    """
973 
    pass
4303 rajveer 974 
 
4662 rajveer 975 
  def markOrderAsLostInTransit(self, orderId):
976 
    """
977 
    Mark order as LOST_IN_TRANSIT
978 
 
979 
    Parameters:
980 
     - orderId
981 
    """
982 
    pass
983 
 
4386 anupam.sin 984 
  def getOrderForAwb(self, awb):
985 
    """
986 
    Returns the order corresponding to an AWB number
4369 rajveer 987 
 
4386 anupam.sin 988 
    Parameters:
989 
     - awb
990 
    """
991 
    pass
992 
 
4910 phani.kuma 993 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 994 
    """
4910 phani.kuma 995 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 996 
 
4506 phani.kuma 997 
    Parameters:
998 
     - logistics_provider_id
4910 phani.kuma 999 
     - order_status_list
4506 phani.kuma 1000 
    """
1001 
    pass
1002 
 
4600 varun.gupt 1003 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1004 
    """
1005 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1006 
 
4600 varun.gupt 1007 
    Parameters:
1008 
     - vendorId
1009 
     - billingDateFrom
1010 
     - billingDateTo
1011 
    """
1012 
    pass
1013 
 
4607 rajveer 1014 
  def getSlippedSippingDateOrders(self, ):
1015 
    pass
1016 
 
4709 rajveer 1017 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1018 
    """
1019 
    Parameters:
1020 
     - cancelDateFrom
1021 
     - cancelDateTo
1022 
    """
1023 
    pass
1024 
 
4600 varun.gupt 1025 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1026 
    """
1027 
    Parameters:
1028 
     - mapAWBAndAmount
1029 
    """
1030 
    pass
1031 
 
4905 varun.gupt 1032 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1033 
    """
1034 
    Parameters:
1035 
     - settlementDate
1036 
     - paymentGatewayId
4905 varun.gupt 1037 
     - referenceId
4600 varun.gupt 1038 
     - serviceTax
1039 
     - otherCharges
1040 
     - netCollection
1041 
    """
1042 
    pass
1043 
 
1044 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1045 
    """
1046 
    Parameters:
1047 
     - settlementId
1048 
     - settlementDate
1049 
     - transactionDateFrom
1050 
     - transactionDateTo
1051 
     - amount
1052 
    """
1053 
    pass
1054 
 
5386 phani.kuma 1055 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1056 
    """
1057 
    Parameters:
5189 varun.gupt 1058 
     - referenceId
1059 
     - isRefund
4600 varun.gupt 1060 
    """
1061 
    pass
1062 
 
5386 phani.kuma 1063 
  def getSettlementForCod(self, orderId, isRefund):
1064 
    """
1065 
    Parameters:
1066 
     - orderId
1067 
     - isRefund
1068 
    """
1069 
    pass
1070 
 
4600 varun.gupt 1071 
  def getEBSSettlementSummaries(self, ):
1072 
    pass
1073 
 
1074 
  def markEBSSettlementUploaded(self, settlementId):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
    """
1079 
    pass
1080 
 
1081 
  def getEBSSettlementDate(self, settlementId):
1082 
    """
1083 
    Parameters:
1084 
     - settlementId
1085 
    """
1086 
    pass
1087 
 
4715 varun.gupt 1088 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1089 
    """
1090 
    Parameters:
1091 
     - settlementDateFrom
1092 
     - settlementDateTo
1093 
     - isRefund
1094 
    """
1095 
    pass
4600 varun.gupt 1096 
 
4715 varun.gupt 1097 
  def getReshippedOrderIds(self, orderIds):
1098 
    """
1099 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1100 
 
1101 
    Parameters:
1102 
     - orderIds
1103 
    """
1104 
    pass
1105 
 
4875 varun.gupt 1106 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1107 
    """
1108 
    Parameters:
1109 
     - vendorId
1110 
    """
1111 
    pass
4757 mandeep.dh 1112 
 
5031 varun.gupt 1113 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1114 
    """
1115 
    Parameters:
1116 
     - startDate
1117 
     - endDate
1118 
    """
1119 
    pass
4875 varun.gupt 1120 
 
5067 varun.gupt 1121 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1122 
    """
1123 
    Parameters:
1124 
     - status
1125 
     - startDatetime
1126 
     - endDatetime
1127 
    """
1128 
    pass
5031 varun.gupt 1129 
 
5348 anupam.sin 1130 
  def updateCODAgent(self, agent, orderId):
1131 
    """
1132 
    Updates the agent who handled the COD verification call
1133 
 
1134 
    Parameters:
1135 
     - agent
1136 
     - orderId
1137 
    """
1138 
    pass
1139 
 
5099 varun.gupt 1140 
  def updateOrderAsPaidToVendor(self, orderId):
1141 
    """
1142 
    Parameters:
1143 
     - orderId
1144 
    """
1145 
    pass
5067 varun.gupt 1146 
 
5386 phani.kuma 1147 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1148 
    """
1149 
    Parameters:
1150 
     - orderId
1151 
    """
1152 
    pass
1153 
 
5208 varun.gupt 1154 
  def getRefundedOrdersMarkedPaid(self, ):
1155 
    pass
5099 varun.gupt 1156 
 
5208 varun.gupt 1157 
 
3376 rajveer 1158 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1159 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1160 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1161 
 
1162 
  def createTransaction(self, transaction):
1163 
    """
1164 
    Parameters:
1165 
     - transaction
1166 
    """
1167 
    self.send_createTransaction(transaction)
132 ashish 1168 
    return self.recv_createTransaction()
94 ashish 1169 
 
1170 
  def send_createTransaction(self, transaction):
1171 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1172 
    args = createTransaction_args()
1173 
    args.transaction = transaction
1174 
    args.write(self._oprot)
1175 
    self._oprot.writeMessageEnd()
1176 
    self._oprot.trans.flush()
1177 
 
1178 
  def recv_createTransaction(self, ):
1179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1180 
    if mtype == TMessageType.EXCEPTION:
1181 
      x = TApplicationException()
1182 
      x.read(self._iprot)
1183 
      self._iprot.readMessageEnd()
1184 
      raise x
1185 
    result = createTransaction_result()
1186 
    result.read(self._iprot)
1187 
    self._iprot.readMessageEnd()
3431 rajveer 1188 
    if result.success is not None:
132 ashish 1189 
      return result.success
3431 rajveer 1190 
    if result.ex is not None:
94 ashish 1191 
      raise result.ex
132 ashish 1192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1193 
 
1194 
  def getTransaction(self, id):
1195 
    """
1196 
    Parameters:
1197 
     - id
1198 
    """
1199 
    self.send_getTransaction(id)
1200 
    return self.recv_getTransaction()
1201 
 
1202 
  def send_getTransaction(self, id):
1203 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1204 
    args = getTransaction_args()
1205 
    args.id = id
1206 
    args.write(self._oprot)
1207 
    self._oprot.writeMessageEnd()
1208 
    self._oprot.trans.flush()
1209 
 
1210 
  def recv_getTransaction(self, ):
1211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1212 
    if mtype == TMessageType.EXCEPTION:
1213 
      x = TApplicationException()
1214 
      x.read(self._iprot)
1215 
      self._iprot.readMessageEnd()
1216 
      raise x
1217 
    result = getTransaction_result()
1218 
    result.read(self._iprot)
1219 
    self._iprot.readMessageEnd()
3431 rajveer 1220 
    if result.success is not None:
94 ashish 1221 
      return result.success
3431 rajveer 1222 
    if result.ex is not None:
94 ashish 1223 
      raise result.ex
1224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1225 
 
1226 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1227 
    """
1228 
    Parameters:
1229 
     - customerId
1230 
     - from_date
1231 
     - to_date
1232 
     - status
1233 
    """
1234 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1235 
    return self.recv_getTransactionsForCustomer()
1236 
 
1237 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1238 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1239 
    args = getTransactionsForCustomer_args()
1240 
    args.customerId = customerId
1241 
    args.from_date = from_date
1242 
    args.to_date = to_date
1243 
    args.status = status
1244 
    args.write(self._oprot)
1245 
    self._oprot.writeMessageEnd()
1246 
    self._oprot.trans.flush()
1247 
 
1248 
  def recv_getTransactionsForCustomer(self, ):
1249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1250 
    if mtype == TMessageType.EXCEPTION:
1251 
      x = TApplicationException()
1252 
      x.read(self._iprot)
1253 
      self._iprot.readMessageEnd()
1254 
      raise x
1255 
    result = getTransactionsForCustomer_result()
1256 
    result.read(self._iprot)
1257 
    self._iprot.readMessageEnd()
3431 rajveer 1258 
    if result.success is not None:
94 ashish 1259 
      return result.success
3431 rajveer 1260 
    if result.ex is not None:
94 ashish 1261 
      raise result.ex
1262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1263 
 
132 ashish 1264 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1265 
    """
1266 
    Parameters:
1267 
     - shoppingCartId
1268 
    """
1269 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1270 
    return self.recv_getTransactionsForShoppingCartId()
1271 
 
1272 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1273 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1274 
    args = getTransactionsForShoppingCartId_args()
1275 
    args.shoppingCartId = shoppingCartId
1276 
    args.write(self._oprot)
1277 
    self._oprot.writeMessageEnd()
1278 
    self._oprot.trans.flush()
1279 
 
1280 
  def recv_getTransactionsForShoppingCartId(self, ):
1281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1282 
    if mtype == TMessageType.EXCEPTION:
1283 
      x = TApplicationException()
1284 
      x.read(self._iprot)
1285 
      self._iprot.readMessageEnd()
1286 
      raise x
1287 
    result = getTransactionsForShoppingCartId_result()
1288 
    result.read(self._iprot)
1289 
    self._iprot.readMessageEnd()
3431 rajveer 1290 
    if result.success is not None:
132 ashish 1291 
      return result.success
3431 rajveer 1292 
    if result.ex is not None:
132 ashish 1293 
      raise result.ex
1294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1295 
 
94 ashish 1296 
  def getTransactionStatus(self, transactionId):
1297 
    """
1298 
    Parameters:
1299 
     - transactionId
1300 
    """
1301 
    self.send_getTransactionStatus(transactionId)
1302 
    return self.recv_getTransactionStatus()
1303 
 
1304 
  def send_getTransactionStatus(self, transactionId):
1305 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1306 
    args = getTransactionStatus_args()
1307 
    args.transactionId = transactionId
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_getTransactionStatus(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = getTransactionStatus_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
3431 rajveer 1322 
    if result.success is not None:
94 ashish 1323 
      return result.success
3431 rajveer 1324 
    if result.ex is not None:
94 ashish 1325 
      raise result.ex
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1327 
 
5387 rajveer 1328 
  def changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1329 
    """
1330 
    Parameters:
1331 
     - transactionId
1332 
     - status
1333 
     - description
5387 rajveer 1334 
     - selfPickup
94 ashish 1335 
    """
5387 rajveer 1336 
    self.send_changeTransactionStatus(transactionId, status, description, selfPickup)
94 ashish 1337 
    return self.recv_changeTransactionStatus()
1338 
 
5387 rajveer 1339 
  def send_changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1340 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1341 
    args = changeTransactionStatus_args()
1342 
    args.transactionId = transactionId
1343 
    args.status = status
1344 
    args.description = description
5387 rajveer 1345 
    args.selfPickup = selfPickup
94 ashish 1346 
    args.write(self._oprot)
1347 
    self._oprot.writeMessageEnd()
1348 
    self._oprot.trans.flush()
1349 
 
1350 
  def recv_changeTransactionStatus(self, ):
1351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1352 
    if mtype == TMessageType.EXCEPTION:
1353 
      x = TApplicationException()
1354 
      x.read(self._iprot)
1355 
      self._iprot.readMessageEnd()
1356 
      raise x
1357 
    result = changeTransactionStatus_result()
1358 
    result.read(self._iprot)
1359 
    self._iprot.readMessageEnd()
3431 rajveer 1360 
    if result.success is not None:
94 ashish 1361 
      return result.success
3431 rajveer 1362 
    if result.ex is not None:
94 ashish 1363 
      raise result.ex
1364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1365 
 
1398 varun.gupt 1366 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1367 
    """
1368 
    Parameters:
1369 
     - transactionId
1370 
    """
1398 varun.gupt 1371 
    self.send_enqueueTransactionInfoEmail(transactionId)
1372 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1373 
 
1398 varun.gupt 1374 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1375 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1376 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1377 
    args.transactionId = transactionId
1378 
    args.write(self._oprot)
1379 
    self._oprot.writeMessageEnd()
1380 
    self._oprot.trans.flush()
1381 
 
1398 varun.gupt 1382 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1384 
    if mtype == TMessageType.EXCEPTION:
1385 
      x = TApplicationException()
1386 
      x.read(self._iprot)
1387 
      self._iprot.readMessageEnd()
1388 
      raise x
1398 varun.gupt 1389 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1390 
    result.read(self._iprot)
1391 
    self._iprot.readMessageEnd()
3431 rajveer 1392 
    if result.success is not None:
1382 varun.gupt 1393 
      return result.success
3431 rajveer 1394 
    if result.ex is not None:
1382 varun.gupt 1395 
      raise result.ex
1398 varun.gupt 1396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1397 
 
4801 anupam.sin 1398 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1399 
    """
1400 
    Parameters:
4801 anupam.sin 1401 
     - statuses
483 rajveer 1402 
     - from_date
1403 
     - to_date
1404 
     - warehouse_id
94 ashish 1405 
    """
4801 anupam.sin 1406 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1407 
    return self.recv_getAllOrders()
94 ashish 1408 
 
4801 anupam.sin 1409 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1410 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1411 
    args = getAllOrders_args()
4801 anupam.sin 1412 
    args.statuses = statuses
483 rajveer 1413 
    args.from_date = from_date
1414 
    args.to_date = to_date
1415 
    args.warehouse_id = warehouse_id
94 ashish 1416 
    args.write(self._oprot)
1417 
    self._oprot.writeMessageEnd()
1418 
    self._oprot.trans.flush()
1419 
 
483 rajveer 1420 
  def recv_getAllOrders(self, ):
94 ashish 1421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1422 
    if mtype == TMessageType.EXCEPTION:
1423 
      x = TApplicationException()
1424 
      x.read(self._iprot)
1425 
      self._iprot.readMessageEnd()
1426 
      raise x
483 rajveer 1427 
    result = getAllOrders_result()
94 ashish 1428 
    result.read(self._iprot)
1429 
    self._iprot.readMessageEnd()
3431 rajveer 1430 
    if result.success is not None:
94 ashish 1431 
      return result.success
3431 rajveer 1432 
    if result.ex is not None:
94 ashish 1433 
      raise result.ex
483 rajveer 1434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1435 
 
4133 chandransh 1436 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1437 
    """
1438 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1439 
    Pass the status as null and the limit as 0 to ignore them.
1440 
 
1441 
    Parameters:
1442 
     - statuses
1443 
     - offset
1444 
     - limit
1445 
     - warehouse_id
1446 
    """
1447 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1448 
    return self.recv_getOrdersInBatch()
1449 
 
1450 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1451 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1452 
    args = getOrdersInBatch_args()
1453 
    args.statuses = statuses
1454 
    args.offset = offset
1455 
    args.limit = limit
1456 
    args.warehouse_id = warehouse_id
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getOrdersInBatch(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getOrdersInBatch_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
1471 
    if result.success is not None:
1472 
      return result.success
1473 
    if result.ex is not None:
1474 
      raise result.ex
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1476 
 
1477 
  def getOrderCount(self, statuses, warehouseId):
1478 
    """
1479 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1480 
 
1481 
    Parameters:
1482 
     - statuses
1483 
     - warehouseId
1484 
    """
1485 
    self.send_getOrderCount(statuses, warehouseId)
1486 
    return self.recv_getOrderCount()
1487 
 
1488 
  def send_getOrderCount(self, statuses, warehouseId):
1489 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1490 
    args = getOrderCount_args()
1491 
    args.statuses = statuses
1492 
    args.warehouseId = warehouseId
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getOrderCount(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getOrderCount_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
1507 
    if result.success is not None:
1508 
      return result.success
1509 
    if result.ex is not None:
1510 
      raise result.ex
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1512 
 
999 varun.gupt 1513 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1514 
    """
1132 chandransh 1515 
    Returns orders within a range of their billing dates
3431 rajveer 1516 
 
999 varun.gupt 1517 
    Parameters:
1518 
     - status
1519 
     - start_billing_date
1520 
     - end_billing_date
1521 
     - warehouse_id
1522 
    """
1523 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1524 
    return self.recv_getOrdersByBillingDate()
1525 
 
1526 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1527 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1528 
    args = getOrdersByBillingDate_args()
1529 
    args.status = status
1530 
    args.start_billing_date = start_billing_date
1531 
    args.end_billing_date = end_billing_date
1532 
    args.warehouse_id = warehouse_id
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getOrdersByBillingDate(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getOrdersByBillingDate_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
3431 rajveer 1547 
    if result.success is not None:
999 varun.gupt 1548 
      return result.success
3431 rajveer 1549 
    if result.ex is not None:
999 varun.gupt 1550 
      raise result.ex
1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1552 
 
3451 chandransh 1553 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1554 
    """
1555 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1556 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1557 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1558 
 
3427 chandransh 1559 
    Parameters:
1560 
     - fromShippingDate
1561 
     - toShippingDate
1562 
     - providerId
1563 
     - warehouseId
3451 chandransh 1564 
     - cod
3427 chandransh 1565 
    """
3451 chandransh 1566 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1567 
    return self.recv_getOrdersByShippingDate()
1568 
 
3451 chandransh 1569 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1570 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1571 
    args = getOrdersByShippingDate_args()
1572 
    args.fromShippingDate = fromShippingDate
1573 
    args.toShippingDate = toShippingDate
1574 
    args.providerId = providerId
1575 
    args.warehouseId = warehouseId
3451 chandransh 1576 
    args.cod = cod
3427 chandransh 1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
1581 
  def recv_getOrdersByShippingDate(self, ):
1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
1588 
    result = getOrdersByShippingDate_result()
1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
3431 rajveer 1591 
    if result.success is not None:
3427 chandransh 1592 
      return result.success
3431 rajveer 1593 
    if result.ex is not None:
3427 chandransh 1594 
      raise result.ex
1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1596 
 
1382 varun.gupt 1597 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1598 
    """
1599 
    Returns order ids for orders which can be returned
3431 rajveer 1600 
 
1382 varun.gupt 1601 
    Parameters:
1602 
     - customer_id
1603 
     - limit
1604 
    """
1605 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1606 
    return self.recv_getReturnableOrdersForCustomer()
1607 
 
1608 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1609 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1610 
    args = getReturnableOrdersForCustomer_args()
1611 
    args.customer_id = customer_id
1612 
    args.limit = limit
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getReturnableOrdersForCustomer(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getReturnableOrdersForCustomer_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
3431 rajveer 1627 
    if result.success is not None:
1382 varun.gupt 1628 
      return result.success
3431 rajveer 1629 
    if result.ex is not None:
1382 varun.gupt 1630 
      raise result.ex
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1632 
 
1633 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1634 
    """
1635 
    Returns order ids for orders which can be cancelled
3431 rajveer 1636 
 
1382 varun.gupt 1637 
    Parameters:
1638 
     - customer_id
1639 
     - limit
1640 
    """
1641 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1642 
    return self.recv_getCancellableOrdersForCustomer()
1643 
 
1644 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1645 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1646 
    args = getCancellableOrdersForCustomer_args()
1647 
    args.customer_id = customer_id
1648 
    args.limit = limit
1649 
    args.write(self._oprot)
1650 
    self._oprot.writeMessageEnd()
1651 
    self._oprot.trans.flush()
1652 
 
1653 
  def recv_getCancellableOrdersForCustomer(self, ):
1654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1655 
    if mtype == TMessageType.EXCEPTION:
1656 
      x = TApplicationException()
1657 
      x.read(self._iprot)
1658 
      self._iprot.readMessageEnd()
1659 
      raise x
1660 
    result = getCancellableOrdersForCustomer_result()
1661 
    result.read(self._iprot)
1662 
    self._iprot.readMessageEnd()
3431 rajveer 1663 
    if result.success is not None:
1382 varun.gupt 1664 
      return result.success
3431 rajveer 1665 
    if result.ex is not None:
1382 varun.gupt 1666 
      raise result.ex
1667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1668 
 
483 rajveer 1669 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1670 
    """
1671 
    Parameters:
483 rajveer 1672 
     - orderId
1673 
     - status
1674 
     - description
94 ashish 1675 
    """
483 rajveer 1676 
    self.send_changeOrderStatus(orderId, status, description)
1677 
    return self.recv_changeOrderStatus()
94 ashish 1678 
 
483 rajveer 1679 
  def send_changeOrderStatus(self, orderId, status, description):
1680 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1681 
    args = changeOrderStatus_args()
1682 
    args.orderId = orderId
1683 
    args.status = status
1684 
    args.description = description
94 ashish 1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
483 rajveer 1689 
  def recv_changeOrderStatus(self, ):
94 ashish 1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
483 rajveer 1696 
    result = changeOrderStatus_result()
94 ashish 1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
3431 rajveer 1699 
    if result.success is not None:
94 ashish 1700 
      return result.success
3431 rajveer 1701 
    if result.ex is not None:
94 ashish 1702 
      raise result.ex
483 rajveer 1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1704 
 
1528 ankur.sing 1705 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1706 
    """
1528 ankur.sing 1707 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1708 
    only user who owns the transaction can view its order details.
3431 rajveer 1709 
 
94 ashish 1710 
    Parameters:
1711 
     - transactionId
1528 ankur.sing 1712 
     - customerId
94 ashish 1713 
    """
1528 ankur.sing 1714 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1715 
    return self.recv_getOrdersForTransaction()
94 ashish 1716 
 
1528 ankur.sing 1717 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1718 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1719 
    args = getOrdersForTransaction_args()
94 ashish 1720 
    args.transactionId = transactionId
1528 ankur.sing 1721 
    args.customerId = customerId
94 ashish 1722 
    args.write(self._oprot)
1723 
    self._oprot.writeMessageEnd()
1724 
    self._oprot.trans.flush()
1725 
 
483 rajveer 1726 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1728 
    if mtype == TMessageType.EXCEPTION:
1729 
      x = TApplicationException()
1730 
      x.read(self._iprot)
1731 
      self._iprot.readMessageEnd()
1732 
      raise x
483 rajveer 1733 
    result = getOrdersForTransaction_result()
94 ashish 1734 
    result.read(self._iprot)
1735 
    self._iprot.readMessageEnd()
3431 rajveer 1736 
    if result.success is not None:
94 ashish 1737 
      return result.success
3431 rajveer 1738 
    if result.ex is not None:
94 ashish 1739 
      raise result.ex
483 rajveer 1740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1741 
 
3014 chandransh 1742 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1743 
    """
3014 chandransh 1744 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1745 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1746 
 
94 ashish 1747 
    Parameters:
483 rajveer 1748 
     - customerId
1749 
     - from_date
1750 
     - to_date
3014 chandransh 1751 
     - statuses
94 ashish 1752 
    """
3014 chandransh 1753 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1754 
    return self.recv_getOrdersForCustomer()
94 ashish 1755 
 
3014 chandransh 1756 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1757 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1758 
    args = getOrdersForCustomer_args()
1759 
    args.customerId = customerId
1760 
    args.from_date = from_date
1761 
    args.to_date = to_date
3014 chandransh 1762 
    args.statuses = statuses
94 ashish 1763 
    args.write(self._oprot)
1764 
    self._oprot.writeMessageEnd()
1765 
    self._oprot.trans.flush()
1766 
 
483 rajveer 1767 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1769 
    if mtype == TMessageType.EXCEPTION:
1770 
      x = TApplicationException()
1771 
      x.read(self._iprot)
1772 
      self._iprot.readMessageEnd()
1773 
      raise x
483 rajveer 1774 
    result = getOrdersForCustomer_result()
94 ashish 1775 
    result.read(self._iprot)
1776 
    self._iprot.readMessageEnd()
3431 rajveer 1777 
    if result.success is not None:
94 ashish 1778 
      return result.success
3431 rajveer 1779 
    if result.ex is not None:
94 ashish 1780 
      raise result.ex
483 rajveer 1781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1782 
 
483 rajveer 1783 
  def createOrder(self, order):
94 ashish 1784 
    """
1785 
    Parameters:
483 rajveer 1786 
     - order
94 ashish 1787 
    """
483 rajveer 1788 
    self.send_createOrder(order)
1789 
    return self.recv_createOrder()
94 ashish 1790 
 
483 rajveer 1791 
  def send_createOrder(self, order):
1792 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1793 
    args = createOrder_args()
1794 
    args.order = order
94 ashish 1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
483 rajveer 1799 
  def recv_createOrder(self, ):
94 ashish 1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
483 rajveer 1806 
    result = createOrder_result()
94 ashish 1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
3431 rajveer 1809 
    if result.success is not None:
94 ashish 1810 
      return result.success
3431 rajveer 1811 
    if result.ex is not None:
94 ashish 1812 
      raise result.ex
483 rajveer 1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1814 
 
483 rajveer 1815 
  def getOrder(self, id):
94 ashish 1816 
    """
1817 
    Parameters:
483 rajveer 1818 
     - id
94 ashish 1819 
    """
483 rajveer 1820 
    self.send_getOrder(id)
1821 
    return self.recv_getOrder()
94 ashish 1822 
 
483 rajveer 1823 
  def send_getOrder(self, id):
1824 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1825 
    args = getOrder_args()
1826 
    args.id = id
94 ashish 1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
483 rajveer 1831 
  def recv_getOrder(self, ):
94 ashish 1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
483 rajveer 1838 
    result = getOrder_result()
94 ashish 1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
3431 rajveer 1841 
    if result.success is not None:
94 ashish 1842 
      return result.success
3431 rajveer 1843 
    if result.ex is not None:
94 ashish 1844 
      raise result.ex
483 rajveer 1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1846 
 
483 rajveer 1847 
  def getLineItemsForOrder(self, orderId):
94 ashish 1848 
    """
1849 
    Parameters:
483 rajveer 1850 
     - orderId
94 ashish 1851 
    """
483 rajveer 1852 
    self.send_getLineItemsForOrder(orderId)
1853 
    return self.recv_getLineItemsForOrder()
94 ashish 1854 
 
483 rajveer 1855 
  def send_getLineItemsForOrder(self, orderId):
1856 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1857 
    args = getLineItemsForOrder_args()
1858 
    args.orderId = orderId
94 ashish 1859 
    args.write(self._oprot)
1860 
    self._oprot.writeMessageEnd()
1861 
    self._oprot.trans.flush()
1862 
 
483 rajveer 1863 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1865 
    if mtype == TMessageType.EXCEPTION:
1866 
      x = TApplicationException()
1867 
      x.read(self._iprot)
1868 
      self._iprot.readMessageEnd()
1869 
      raise x
483 rajveer 1870 
    result = getLineItemsForOrder_result()
94 ashish 1871 
    result.read(self._iprot)
1872 
    self._iprot.readMessageEnd()
3431 rajveer 1873 
    if result.success is not None:
94 ashish 1874 
      return result.success
3431 rajveer 1875 
    if result.ex is not None:
94 ashish 1876 
      raise result.ex
483 rajveer 1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1878 
 
4999 phani.kuma 1879 
  def getOrderList(self, order_ids):
1880 
    """
1881 
    Parameters:
1882 
     - order_ids
1883 
    """
1884 
    self.send_getOrderList(order_ids)
1885 
    return self.recv_getOrderList()
1886 
 
1887 
  def send_getOrderList(self, order_ids):
1888 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1889 
    args = getOrderList_args()
1890 
    args.order_ids = order_ids
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getOrderList(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getOrderList_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
1905 
    if result.success is not None:
1906 
      return result.success
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1908 
 
5386 phani.kuma 1909 
  def getOrderListForVendor(self, order_ids, vendorId):
1910 
    """
1911 
    Parameters:
1912 
     - order_ids
1913 
     - vendorId
1914 
    """
1915 
    self.send_getOrderListForVendor(order_ids, vendorId)
1916 
    return self.recv_getOrderListForVendor()
1917 
 
1918 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1919 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1920 
    args = getOrderListForVendor_args()
1921 
    args.order_ids = order_ids
1922 
    args.vendorId = vendorId
1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1927 
  def recv_getOrderListForVendor(self, ):
1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1934 
    result = getOrderListForVendor_result()
1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
1937 
    if result.success is not None:
1938 
      return result.success
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
1940 
 
1528 ankur.sing 1941 
  def getOrderForCustomer(self, orderId, customerId):
1942 
    """
1943 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1944 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1945 
 
1528 ankur.sing 1946 
    Parameters:
1947 
     - orderId
1948 
     - customerId
1949 
    """
1950 
    self.send_getOrderForCustomer(orderId, customerId)
1951 
    return self.recv_getOrderForCustomer()
1952 
 
1953 
  def send_getOrderForCustomer(self, orderId, customerId):
1954 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1955 
    args = getOrderForCustomer_args()
1956 
    args.orderId = orderId
1957 
    args.customerId = customerId
1958 
    args.write(self._oprot)
1959 
    self._oprot.writeMessageEnd()
1960 
    self._oprot.trans.flush()
1961 
 
1962 
  def recv_getOrderForCustomer(self, ):
1963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1964 
    if mtype == TMessageType.EXCEPTION:
1965 
      x = TApplicationException()
1966 
      x.read(self._iprot)
1967 
      self._iprot.readMessageEnd()
1968 
      raise x
1969 
    result = getOrderForCustomer_result()
1970 
    result.read(self._iprot)
1971 
    self._iprot.readMessageEnd()
3431 rajveer 1972 
    if result.success is not None:
1528 ankur.sing 1973 
      return result.success
3431 rajveer 1974 
    if result.ex is not None:
1528 ankur.sing 1975 
      raise result.ex
1976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1977 
 
4444 rajveer 1978 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1979 
    """
1980 
    Parameters:
4394 rajveer 1981 
     - type
4444 rajveer 1982 
     - warehouseId
4394 rajveer 1983 
     - status
1984 
     - timestamp
3064 chandransh 1985 
    """
4444 rajveer 1986 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1987 
    return self.recv_getAlerts()
1988 
 
4444 rajveer 1989 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1990 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1991 
    args = getAlerts_args()
4394 rajveer 1992 
    args.type = type
4444 rajveer 1993 
    args.warehouseId = warehouseId
4394 rajveer 1994 
    args.status = status
1995 
    args.timestamp = timestamp
3064 chandransh 1996 
    args.write(self._oprot)
1997 
    self._oprot.writeMessageEnd()
1998 
    self._oprot.trans.flush()
1999 
 
2000 
  def recv_getAlerts(self, ):
2001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2002 
    if mtype == TMessageType.EXCEPTION:
2003 
      x = TApplicationException()
2004 
      x.read(self._iprot)
2005 
      self._iprot.readMessageEnd()
2006 
      raise x
2007 
    result = getAlerts_result()
2008 
    result.read(self._iprot)
2009 
    self._iprot.readMessageEnd()
3431 rajveer 2010 
    if result.success is not None:
3064 chandransh 2011 
      return result.success
2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2013 
 
4444 rajveer 2014 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2015 
    """
2016 
    Parameters:
2017 
     - type
4444 rajveer 2018 
     - warehouseId
4394 rajveer 2019 
     - description
3064 chandransh 2020 
    """
4444 rajveer 2021 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2022 
    self.recv_addAlert()
3064 chandransh 2023 
 
4444 rajveer 2024 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2025 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2026 
    args = addAlert_args()
3064 chandransh 2027 
    args.type = type
4444 rajveer 2028 
    args.warehouseId = warehouseId
4394 rajveer 2029 
    args.description = description
3064 chandransh 2030 
    args.write(self._oprot)
2031 
    self._oprot.writeMessageEnd()
2032 
    self._oprot.trans.flush()
2033 
 
4394 rajveer 2034 
  def recv_addAlert(self, ):
3064 chandransh 2035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2036 
    if mtype == TMessageType.EXCEPTION:
2037 
      x = TApplicationException()
2038 
      x.read(self._iprot)
2039 
      self._iprot.readMessageEnd()
2040 
      raise x
4394 rajveer 2041 
    result = addAlert_result()
3064 chandransh 2042 
    result.read(self._iprot)
2043 
    self._iprot.readMessageEnd()
2044 
    return
2045 
 
4444 rajveer 2046 
  def markAlertsAsSeen(self, warehouseId):
2047 
    """
2048 
    Parameters:
2049 
     - warehouseId
2050 
    """
2051 
    self.send_markAlertsAsSeen(warehouseId)
2052 
    self.recv_markAlertsAsSeen()
2053 
 
2054 
  def send_markAlertsAsSeen(self, warehouseId):
2055 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2056 
    args = markAlertsAsSeen_args()
2057 
    args.warehouseId = warehouseId
2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
2062 
  def recv_markAlertsAsSeen(self, ):
2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
2069 
    result = markAlertsAsSeen_result()
2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
2072 
    return
2073 
 
3064 chandransh 2074 
  def getValidOrderCount(self, ):
2075 
    """
2076 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2077 
    """
2078 
    self.send_getValidOrderCount()
2079 
    return self.recv_getValidOrderCount()
2080 
 
2081 
  def send_getValidOrderCount(self, ):
2082 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2083 
    args = getValidOrderCount_args()
2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
2088 
  def recv_getValidOrderCount(self, ):
2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
2095 
    result = getValidOrderCount_result()
2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
3431 rajveer 2098 
    if result.success is not None:
3064 chandransh 2099 
      return result.success
2100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2101 
 
2102 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2103 
    """
2104 
    Returns the number of distinct customers who have done successful transactions
2105 
    """
2106 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2107 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2108 
 
2109 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2110 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2111 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2112 
    args.write(self._oprot)
2113 
    self._oprot.writeMessageEnd()
2114 
    self._oprot.trans.flush()
2115 
 
2116 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2118 
    if mtype == TMessageType.EXCEPTION:
2119 
      x = TApplicationException()
2120 
      x.read(self._iprot)
2121 
      self._iprot.readMessageEnd()
2122 
      raise x
2123 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2124 
    result.read(self._iprot)
2125 
    self._iprot.readMessageEnd()
3431 rajveer 2126 
    if result.success is not None:
3064 chandransh 2127 
      return result.success
2128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2129 
 
2130 
  def getValidOrdersAmountRange(self, ):
2131 
    """
2132 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2133 
    List contains two values, first minimum amount and second maximum amount.
2134 
    """
2135 
    self.send_getValidOrdersAmountRange()
2136 
    return self.recv_getValidOrdersAmountRange()
2137 
 
2138 
  def send_getValidOrdersAmountRange(self, ):
2139 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2140 
    args = getValidOrdersAmountRange_args()
2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
2145 
  def recv_getValidOrdersAmountRange(self, ):
2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
2152 
    result = getValidOrdersAmountRange_result()
2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
3431 rajveer 2155 
    if result.success is not None:
3064 chandransh 2156 
      return result.success
2157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2158 
 
2159 
  def getValidOrders(self, limit):
2160 
    """
2161 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2162 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2163 
 
3064 chandransh 2164 
    Parameters:
2165 
     - limit
2166 
    """
2167 
    self.send_getValidOrders(limit)
2168 
    return self.recv_getValidOrders()
2169 
 
2170 
  def send_getValidOrders(self, limit):
2171 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2172 
    args = getValidOrders_args()
2173 
    args.limit = limit
2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
2178 
  def recv_getValidOrders(self, ):
2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
2185 
    result = getValidOrders_result()
2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
3431 rajveer 2188 
    if result.success is not None:
3064 chandransh 2189 
      return result.success
2190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2191 
 
1220 chandransh 2192 
  def batchOrders(self, warehouseId):
2193 
    """
2194 
    Create a batch of all the pending orders for the given warehouse.
2195 
    The returned list is orderd by created_timestamp.
2196 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2197 
 
1220 chandransh 2198 
    Parameters:
2199 
     - warehouseId
2200 
    """
2201 
    self.send_batchOrders(warehouseId)
2202 
    return self.recv_batchOrders()
2203 
 
2204 
  def send_batchOrders(self, warehouseId):
2205 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2206 
    args = batchOrders_args()
2207 
    args.warehouseId = warehouseId
2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
2212 
  def recv_batchOrders(self, ):
2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
2219 
    result = batchOrders_result()
2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
3431 rajveer 2222 
    if result.success is not None:
1220 chandransh 2223 
      return result.success
3431 rajveer 2224 
    if result.ex is not None:
1220 chandransh 2225 
      raise result.ex
2226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2227 
 
1208 chandransh 2228 
  def markOrderAsOutOfStock(self, orderId):
2229 
    """
2230 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2231 
 
1208 chandransh 2232 
    Parameters:
2233 
     - orderId
2234 
    """
2235 
    self.send_markOrderAsOutOfStock(orderId)
2236 
    return self.recv_markOrderAsOutOfStock()
2237 
 
2238 
  def send_markOrderAsOutOfStock(self, orderId):
2239 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2240 
    args = markOrderAsOutOfStock_args()
2241 
    args.orderId = orderId
2242 
    args.write(self._oprot)
2243 
    self._oprot.writeMessageEnd()
2244 
    self._oprot.trans.flush()
2245 
 
2246 
  def recv_markOrderAsOutOfStock(self, ):
2247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2248 
    if mtype == TMessageType.EXCEPTION:
2249 
      x = TApplicationException()
2250 
      x.read(self._iprot)
2251 
      self._iprot.readMessageEnd()
2252 
      raise x
2253 
    result = markOrderAsOutOfStock_result()
2254 
    result.read(self._iprot)
2255 
    self._iprot.readMessageEnd()
3431 rajveer 2256 
    if result.success is not None:
1208 chandransh 2257 
      return result.success
3431 rajveer 2258 
    if result.ex is not None:
1208 chandransh 2259 
      raise result.ex
2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2261 
 
3064 chandransh 2262 
  def verifyOrder(self, orderId):
759 chandransh 2263 
    """
3064 chandransh 2264 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2265 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2266 
    used for all other orders as well.
2267 
    Throws an exception if no such order exists.
3431 rajveer 2268 
 
759 chandransh 2269 
    Parameters:
3064 chandransh 2270 
     - orderId
759 chandransh 2271 
    """
3064 chandransh 2272 
    self.send_verifyOrder(orderId)
2273 
    return self.recv_verifyOrder()
759 chandransh 2274 
 
3064 chandransh 2275 
  def send_verifyOrder(self, orderId):
2276 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2277 
    args = verifyOrder_args()
2278 
    args.orderId = orderId
759 chandransh 2279 
    args.write(self._oprot)
2280 
    self._oprot.writeMessageEnd()
2281 
    self._oprot.trans.flush()
2282 
 
3064 chandransh 2283 
  def recv_verifyOrder(self, ):
759 chandransh 2284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2285 
    if mtype == TMessageType.EXCEPTION:
2286 
      x = TApplicationException()
2287 
      x.read(self._iprot)
2288 
      self._iprot.readMessageEnd()
2289 
      raise x
3064 chandransh 2290 
    result = verifyOrder_result()
759 chandransh 2291 
    result.read(self._iprot)
2292 
    self._iprot.readMessageEnd()
3431 rajveer 2293 
    if result.success is not None:
759 chandransh 2294 
      return result.success
3431 rajveer 2295 
    if result.ex is not None:
759 chandransh 2296 
      raise result.ex
3064 chandransh 2297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2298 
 
3064 chandransh 2299 
  def acceptOrder(self, orderId):
1113 chandransh 2300 
    """
3064 chandransh 2301 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2302 
    given order is not a COD order, it also captures the payment if the same has
2303 
    not been captured.
2304 
    Throws an exception if no such order exists.
3431 rajveer 2305 
 
1113 chandransh 2306 
    Parameters:
3064 chandransh 2307 
     - orderId
1113 chandransh 2308 
    """
3064 chandransh 2309 
    self.send_acceptOrder(orderId)
2310 
    return self.recv_acceptOrder()
1113 chandransh 2311 
 
3064 chandransh 2312 
  def send_acceptOrder(self, orderId):
2313 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2314 
    args = acceptOrder_args()
2315 
    args.orderId = orderId
1113 chandransh 2316 
    args.write(self._oprot)
2317 
    self._oprot.writeMessageEnd()
2318 
    self._oprot.trans.flush()
2319 
 
3064 chandransh 2320 
  def recv_acceptOrder(self, ):
1113 chandransh 2321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2322 
    if mtype == TMessageType.EXCEPTION:
2323 
      x = TApplicationException()
2324 
      x.read(self._iprot)
2325 
      self._iprot.readMessageEnd()
2326 
      raise x
3064 chandransh 2327 
    result = acceptOrder_result()
1113 chandransh 2328 
    result.read(self._iprot)
2329 
    self._iprot.readMessageEnd()
3431 rajveer 2330 
    if result.success is not None:
1113 chandransh 2331 
      return result.success
3431 rajveer 2332 
    if result.ex is not None:
1113 chandransh 2333 
      raise result.ex
3064 chandransh 2334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2335 
 
5110 mandeep.dh 2336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2337 
    """
3064 chandransh 2338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2340 
    the IMEI no. if a -1 is supplied.
2341 
    Also, it generates an invoice number for the order, marks the order as
2342 
    BILLED and sets the billing timestamp.
2343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2344 
 
1135 chandransh 2345 
    Parameters:
3064 chandransh 2346 
     - orderId
2347 
     - invoice_number
4658 mandeep.dh 2348 
     - serialNumber
4283 anupam.sin 2349 
     - itemNumber
3064 chandransh 2350 
     - billed_by
4264 rajveer 2351 
     - jacketNumber
4283 anupam.sin 2352 
     - billingType
5110 mandeep.dh 2353 
     - fulfilmentWarehouseId
4763 rajveer 2354 
     - authorize
1135 chandransh 2355 
    """
5110 mandeep.dh 2356 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2357 
    return self.recv_addBillingDetails()
1135 chandransh 2358 
 
5110 mandeep.dh 2359 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2360 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2361 
    args = addBillingDetails_args()
2362 
    args.orderId = orderId
2363 
    args.invoice_number = invoice_number
4658 mandeep.dh 2364 
    args.serialNumber = serialNumber
4283 anupam.sin 2365 
    args.itemNumber = itemNumber
3064 chandransh 2366 
    args.billed_by = billed_by
4264 rajveer 2367 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2368 
    args.billingType = billingType
5110 mandeep.dh 2369 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2370 
    args.authorize = authorize
1135 chandransh 2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
3064 chandransh 2375 
  def recv_addBillingDetails(self, ):
1135 chandransh 2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
3064 chandransh 2382 
    result = addBillingDetails_result()
1135 chandransh 2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
3431 rajveer 2385 
    if result.success is not None:
3064 chandransh 2386 
      return result.success
3431 rajveer 2387 
    if result.ex is not None:
1135 chandransh 2388 
      raise result.ex
3064 chandransh 2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2390 
 
4763 rajveer 2391 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2392 
    """
2393 
    Add the invoice number to the order.
2394 
 
2395 
    Parameters:
2396 
     - orderId
2397 
     - invoiceNumber
4763 rajveer 2398 
     - color
4579 rajveer 2399 
    """
4763 rajveer 2400 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2401 
    self.recv_addInvoiceNumber()
2402 
 
4763 rajveer 2403 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2404 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2405 
    args = addInvoiceNumber_args()
2406 
    args.orderId = orderId
2407 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2408 
    args.color = color
4579 rajveer 2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_addInvoiceNumber(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = addInvoiceNumber_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.ex is not None:
2424 
      raise result.ex
2425 
    return
2426 
 
4910 phani.kuma 2427 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2428 
    """
3064 chandransh 2429 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2430 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2431 
 
1408 ankur.sing 2432 
    Parameters:
3064 chandransh 2433 
     - warehouseId
1408 ankur.sing 2434 
     - providerId
3064 chandransh 2435 
     - cod
4910 phani.kuma 2436 
     - orderIds
1408 ankur.sing 2437 
    """
4910 phani.kuma 2438 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2439 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2440 
 
4910 phani.kuma 2441 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2442 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2443 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2444 
    args.warehouseId = warehouseId
1408 ankur.sing 2445 
    args.providerId = providerId
3064 chandransh 2446 
    args.cod = cod
4910 phani.kuma 2447 
    args.orderIds = orderIds
1408 ankur.sing 2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
4910 phani.kuma 2452 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
4910 phani.kuma 2459 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.success is not None:
1408 ankur.sing 2463 
      return result.success
3431 rajveer 2464 
    if result.ex is not None:
3064 chandransh 2465 
      raise result.ex
4910 phani.kuma 2466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2467 
 
4910 phani.kuma 2468 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2469 
    """
4910 phani.kuma 2470 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2471 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2472 
 
2473 
    Parameters:
2474 
     - providerId
4910 phani.kuma 2475 
     - pickupDetails
4410 rajveer 2476 
    """
4910 phani.kuma 2477 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2478 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2479 
 
4910 phani.kuma 2480 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2481 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2482 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2483 
    args.providerId = providerId
4910 phani.kuma 2484 
    args.pickupDetails = pickupDetails
4410 rajveer 2485 
    args.write(self._oprot)
2486 
    self._oprot.writeMessageEnd()
2487 
    self._oprot.trans.flush()
2488 
 
4910 phani.kuma 2489 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2491 
    if mtype == TMessageType.EXCEPTION:
2492 
      x = TApplicationException()
2493 
      x.read(self._iprot)
2494 
      self._iprot.readMessageEnd()
2495 
      raise x
4910 phani.kuma 2496 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2497 
    result.read(self._iprot)
2498 
    self._iprot.readMessageEnd()
2499 
    if result.ex is not None:
2500 
      raise result.ex
4910 phani.kuma 2501 
    return
4410 rajveer 2502 
 
4910 phani.kuma 2503 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2504 
    """
3064 chandransh 2505 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2506 
 
94 ashish 2507 
    Parameters:
3064 chandransh 2508 
     - providerId
304 ashish 2509 
    """
4910 phani.kuma 2510 
    self.send_getOrdersNotPickedUp(providerId)
2511 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2512 
 
4910 phani.kuma 2513 
  def send_getOrdersNotPickedUp(self, providerId):
2514 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2515 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2516 
    args.providerId = providerId
304 ashish 2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
4910 phani.kuma 2521 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
4910 phani.kuma 2528 
    result = getOrdersNotPickedUp_result()
304 ashish 2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
3431 rajveer 2531 
    if result.success is not None:
304 ashish 2532 
      return result.success
4910 phani.kuma 2533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2534 
 
3064 chandransh 2535 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2536 
    """
3064 chandransh 2537 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2538 
    the name of the receiver.
2539 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2540 
 
304 ashish 2541 
    Parameters:
3064 chandransh 2542 
     - providerId
2543 
     - deliveredOrders
304 ashish 2544 
    """
3064 chandransh 2545 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2546 
    self.recv_markOrdersAsDelivered()
304 ashish 2547 
 
3064 chandransh 2548 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2549 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2550 
    args = markOrdersAsDelivered_args()
2551 
    args.providerId = providerId
2552 
    args.deliveredOrders = deliveredOrders
304 ashish 2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
3064 chandransh 2557 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
3064 chandransh 2564 
    result = markOrdersAsDelivered_result()
304 ashish 2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
3431 rajveer 2567 
    if result.ex is not None:
3064 chandransh 2568 
      raise result.ex
304 ashish 2569 
    return
2570 
 
4910 phani.kuma 2571 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2572 
    """
4910 phani.kuma 2573 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2574 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2575 
 
3064 chandransh 2576 
    Parameters:
2577 
     - providerId
2578 
     - returnedOrders
1596 ankur.sing 2579 
    """
4910 phani.kuma 2580 
    self.send_markAsRTOrders(providerId, returnedOrders)
2581 
    self.recv_markAsRTOrders()
304 ashish 2582 
 
4910 phani.kuma 2583 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2584 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2585 
    args = markAsRTOrders_args()
3064 chandransh 2586 
    args.providerId = providerId
2587 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
4910 phani.kuma 2592 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
4910 phani.kuma 2599 
    result = markAsRTOrders_result()
1596 ankur.sing 2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
3431 rajveer 2602 
    if result.ex is not None:
3064 chandransh 2603 
      raise result.ex
2604 
    return
1596 ankur.sing 2605 
 
4910 phani.kuma 2606 
  def getRTOrders(self, providerId):
2607 
    """
2608 
    Returns a list of orders that were returned by courier.
2609 
 
2610 
    Parameters:
2611 
     - providerId
2612 
    """
2613 
    self.send_getRTOrders(providerId)
2614 
    return self.recv_getRTOrders()
2615 
 
2616 
  def send_getRTOrders(self, providerId):
2617 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2618 
    args = getRTOrders_args()
2619 
    args.providerId = providerId
2620 
    args.write(self._oprot)
2621 
    self._oprot.writeMessageEnd()
2622 
    self._oprot.trans.flush()
2623 
 
2624 
  def recv_getRTOrders(self, ):
2625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2626 
    if mtype == TMessageType.EXCEPTION:
2627 
      x = TApplicationException()
2628 
      x.read(self._iprot)
2629 
      self._iprot.readMessageEnd()
2630 
      raise x
2631 
    result = getRTOrders_result()
2632 
    result.read(self._iprot)
2633 
    self._iprot.readMessageEnd()
2634 
    if result.success is not None:
2635 
      return result.success
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2637 
 
3064 chandransh 2638 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2639 
    """
3064 chandransh 2640 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2641 
 
3064 chandransh 2642 
    Parameters:
2643 
     - providerId
2644 
     - undeliveredOrders
1627 ankur.sing 2645 
    """
3064 chandransh 2646 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2647 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2648 
 
3064 chandransh 2649 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2650 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2651 
    args = updateNonDeliveryReason_args()
2652 
    args.providerId = providerId
2653 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2654 
    args.write(self._oprot)
2655 
    self._oprot.writeMessageEnd()
2656 
    self._oprot.trans.flush()
2657 
 
3064 chandransh 2658 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2660 
    if mtype == TMessageType.EXCEPTION:
2661 
      x = TApplicationException()
2662 
      x.read(self._iprot)
2663 
      self._iprot.readMessageEnd()
2664 
      raise x
3064 chandransh 2665 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2666 
    result.read(self._iprot)
2667 
    self._iprot.readMessageEnd()
4910 phani.kuma 2668 
    if result.ex is not None:
2669 
      raise result.ex
2670 
    return
2671 
 
2672 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2673 
    """
2674 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2675 
 
2676 
    Parameters:
2677 
     - providerId
2678 
    """
2679 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2680 
    return self.recv_getNonDeliveredOrdersbyCourier()
2681 
 
2682 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2683 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2684 
    args = getNonDeliveredOrdersbyCourier_args()
2685 
    args.providerId = providerId
2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2690 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2697 
    result = getNonDeliveredOrdersbyCourier_result()
2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
4581 phani.kuma 2700 
    if result.success is not None:
2701 
      return result.success
4910 phani.kuma 2702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2703 
 
2704 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2705 
    """
2706 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2707 
 
2708 
    Parameters:
2709 
     - providerId
2710 
     - local_connected_orders
2711 
    """
2712 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2713 
    self.recv_markOrdersAsLocalConnected()
2714 
 
2715 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2716 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2717 
    args = markOrdersAsLocalConnected_args()
2718 
    args.providerId = providerId
2719 
    args.local_connected_orders = local_connected_orders
2720 
    args.write(self._oprot)
2721 
    self._oprot.writeMessageEnd()
2722 
    self._oprot.trans.flush()
2723 
 
2724 
  def recv_markOrdersAsLocalConnected(self, ):
2725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2726 
    if mtype == TMessageType.EXCEPTION:
2727 
      x = TApplicationException()
2728 
      x.read(self._iprot)
2729 
      self._iprot.readMessageEnd()
2730 
      raise x
2731 
    result = markOrdersAsLocalConnected_result()
2732 
    result.read(self._iprot)
2733 
    self._iprot.readMessageEnd()
3431 rajveer 2734 
    if result.ex is not None:
3064 chandransh 2735 
      raise result.ex
4910 phani.kuma 2736 
    return
1627 ankur.sing 2737 
 
4910 phani.kuma 2738 
  def getOrdersNotLocalConnected(self, providerId):
2739 
    """
2740 
    Returns a list of orders that were picked up or shipped but pending local connection.
2741 
 
2742 
    Parameters:
2743 
     - providerId
2744 
    """
2745 
    self.send_getOrdersNotLocalConnected(providerId)
2746 
    return self.recv_getOrdersNotLocalConnected()
2747 
 
2748 
  def send_getOrdersNotLocalConnected(self, providerId):
2749 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2750 
    args = getOrdersNotLocalConnected_args()
2751 
    args.providerId = providerId
2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2756 
  def recv_getOrdersNotLocalConnected(self, ):
2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2763 
    result = getOrdersNotLocalConnected_result()
2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
2766 
    if result.success is not None:
2767 
      return result.success
2768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2769 
 
2770 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2771 
    """
2772 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2773 
 
2774 
    Parameters:
2775 
     - providerId
2776 
     - destination_city_reached_orders
2777 
    """
2778 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2779 
    self.recv_markOrdersAsDestinationCityReached()
2780 
 
2781 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2782 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2783 
    args = markOrdersAsDestinationCityReached_args()
2784 
    args.providerId = providerId
2785 
    args.destination_city_reached_orders = destination_city_reached_orders
2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2790 
  def recv_markOrdersAsDestinationCityReached(self, ):
2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2797 
    result = markOrdersAsDestinationCityReached_result()
2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
2800 
    if result.ex is not None:
2801 
      raise result.ex
2802 
    return
2803 
 
2804 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2805 
    """
2806 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2807 
 
2808 
    Parameters:
2809 
     - providerId
2810 
     - first_atdl_orders
2811 
    """
2812 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2813 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2814 
 
2815 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2816 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2817 
    args = markOrdersAsFirstDeliveryAttempted_args()
2818 
    args.providerId = providerId
2819 
    args.first_atdl_orders = first_atdl_orders
2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2824 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2831 
    result = markOrdersAsFirstDeliveryAttempted_result()
2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
2834 
    if result.ex is not None:
2835 
      raise result.ex
2836 
    return
2837 
 
3064 chandransh 2838 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2839 
    """
3064 chandransh 2840 
    Returns the list of orders whose delivery time has passed but have not been
2841 
    delivered yet for the given provider and warehouse. To get a complete list of
2842 
    undelivered orders, pass them as -1.
2843 
    Returns an empty list if no such orders exist.
3431 rajveer 2844 
 
1886 ankur.sing 2845 
    Parameters:
3064 chandransh 2846 
     - providerId
2847 
     - warehouseId
1886 ankur.sing 2848 
    """
3064 chandransh 2849 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2850 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2851 
 
3064 chandransh 2852 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2853 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2854 
    args = getUndeliveredOrders_args()
2855 
    args.providerId = providerId
2856 
    args.warehouseId = warehouseId
1886 ankur.sing 2857 
    args.write(self._oprot)
2858 
    self._oprot.writeMessageEnd()
2859 
    self._oprot.trans.flush()
2860 
 
3064 chandransh 2861 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2863 
    if mtype == TMessageType.EXCEPTION:
2864 
      x = TApplicationException()
2865 
      x.read(self._iprot)
2866 
      self._iprot.readMessageEnd()
2867 
      raise x
3064 chandransh 2868 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2869 
    result.read(self._iprot)
2870 
    self._iprot.readMessageEnd()
3431 rajveer 2871 
    if result.success is not None:
1886 ankur.sing 2872 
      return result.success
3064 chandransh 2873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2874 
 
4783 phani.kuma 2875 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2876 
    """
2877 
    Returns the list of orders whose expected delivery date has passed but have not been
2878 
    delivered yet.
2879 
    Returns an empty list if no such orders exist.
2880 
    """
2881 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2882 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2883 
 
2884 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2885 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2886 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
2891 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
2898 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
2901 
    if result.success is not None:
2902 
      return result.success
2903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2904 
 
2536 chandransh 2905 
  def toggleDOAFlag(self, orderId):
2906 
    """
2907 
    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.
2908 
    Returns the final flag status.
2909 
    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 2910 
 
2536 chandransh 2911 
    Parameters:
2912 
     - orderId
2913 
    """
2914 
    self.send_toggleDOAFlag(orderId)
2915 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2916 
 
2536 chandransh 2917 
  def send_toggleDOAFlag(self, orderId):
2918 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2919 
    args = toggleDOAFlag_args()
2920 
    args.orderId = orderId
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_toggleDOAFlag(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = toggleDOAFlag_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
3431 rajveer 2935 
    if result.success is not None:
2536 chandransh 2936 
      return result.success
3431 rajveer 2937 
    if result.ex is not None:
2536 chandransh 2938 
      raise result.ex
2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2940 
 
4712 rajveer 2941 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2942 
    """
2943 
    Parameters:
2944 
     - orderId
2945 
     - deliveryTimestamp
2946 
     - receiver
2947 
    """
2948 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2949 
    self.recv_markOrderAsDelivered()
2950 
 
2951 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2952 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2953 
    args = markOrderAsDelivered_args()
2954 
    args.orderId = orderId
2955 
    args.deliveryTimestamp = deliveryTimestamp
2956 
    args.receiver = receiver
2957 
    args.write(self._oprot)
2958 
    self._oprot.writeMessageEnd()
2959 
    self._oprot.trans.flush()
2960 
 
2961 
  def recv_markOrderAsDelivered(self, ):
2962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2963 
    if mtype == TMessageType.EXCEPTION:
2964 
      x = TApplicationException()
2965 
      x.read(self._iprot)
2966 
      self._iprot.readMessageEnd()
2967 
      raise x
2968 
    result = markOrderAsDelivered_result()
2969 
    result.read(self._iprot)
2970 
    self._iprot.readMessageEnd()
2971 
    if result.ex is not None:
2972 
      raise result.ex
2973 
    return
2974 
 
4454 rajveer 2975 
  def markOrderDoaRequestReceived(self, orderId):
2976 
    """
2977 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2978 
 
2979 
    Parameters:
2980 
     - orderId
2981 
    """
2982 
    self.send_markOrderDoaRequestReceived(orderId)
2983 
    return self.recv_markOrderDoaRequestReceived()
2984 
 
2985 
  def send_markOrderDoaRequestReceived(self, orderId):
2986 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2987 
    args = markOrderDoaRequestReceived_args()
2988 
    args.orderId = orderId
2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_markOrderDoaRequestReceived(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = markOrderDoaRequestReceived_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    if result.ex is not None:
3006 
      raise result.ex
3007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3008 
 
3009 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3010 
    """
3011 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3012 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3013 
 
3014 
    Parameters:
3015 
     - orderId
3016 
     - isAuthorized
3017 
    """
3018 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3019 
    return self.recv_markOrderDoaRequestAuthorized()
3020 
 
3021 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3022 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3023 
    args = markOrderDoaRequestAuthorized_args()
3024 
    args.orderId = orderId
3025 
    args.isAuthorized = isAuthorized
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_markOrderDoaRequestAuthorized(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = markOrderDoaRequestAuthorized_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3040 
    if result.success is not None:
3041 
      return result.success
3042 
    if result.ex is not None:
3043 
      raise result.ex
3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3045 
 
4488 rajveer 3046 
  def markOrderReturnRequestReceived(self, orderId):
3047 
    """
3048 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3049 
 
3050 
    Parameters:
3051 
     - orderId
3052 
    """
3053 
    self.send_markOrderReturnRequestReceived(orderId)
3054 
    return self.recv_markOrderReturnRequestReceived()
3055 
 
3056 
  def send_markOrderReturnRequestReceived(self, orderId):
3057 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3058 
    args = markOrderReturnRequestReceived_args()
3059 
    args.orderId = orderId
3060 
    args.write(self._oprot)
3061 
    self._oprot.writeMessageEnd()
3062 
    self._oprot.trans.flush()
3063 
 
3064 
  def recv_markOrderReturnRequestReceived(self, ):
3065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3066 
    if mtype == TMessageType.EXCEPTION:
3067 
      x = TApplicationException()
3068 
      x.read(self._iprot)
3069 
      self._iprot.readMessageEnd()
3070 
      raise x
3071 
    result = markOrderReturnRequestReceived_result()
3072 
    result.read(self._iprot)
3073 
    self._iprot.readMessageEnd()
3074 
    if result.success is not None:
3075 
      return result.success
3076 
    if result.ex is not None:
3077 
      raise result.ex
3078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3079 
 
3080 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3081 
    """
3082 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3083 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3084 
 
3085 
    Parameters:
3086 
     - orderId
3087 
     - isAuthorized
3088 
    """
3089 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3090 
    return self.recv_markOrderReturnRequestAuthorized()
3091 
 
3092 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3093 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3094 
    args = markOrderReturnRequestAuthorized_args()
3095 
    args.orderId = orderId
3096 
    args.isAuthorized = isAuthorized
3097 
    args.write(self._oprot)
3098 
    self._oprot.writeMessageEnd()
3099 
    self._oprot.trans.flush()
3100 
 
3101 
  def recv_markOrderReturnRequestAuthorized(self, ):
3102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3103 
    if mtype == TMessageType.EXCEPTION:
3104 
      x = TApplicationException()
3105 
      x.read(self._iprot)
3106 
      self._iprot.readMessageEnd()
3107 
      raise x
3108 
    result = markOrderReturnRequestAuthorized_result()
3109 
    result.read(self._iprot)
3110 
    self._iprot.readMessageEnd()
3111 
    if result.success is not None:
3112 
      return result.success
3113 
    if result.ex is not None:
3114 
      raise result.ex
3115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3116 
 
4579 rajveer 3117 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3118 
    """
3119 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3120 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3121 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3122 
    For any other status, it returns false.
3123 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3124 
 
2536 chandransh 3125 
    Parameters:
3126 
     - orderId
4579 rajveer 3127 
     - providerId
2536 chandransh 3128 
    """
4579 rajveer 3129 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3130 
    return self.recv_requestPickupNumber()
3131 
 
4579 rajveer 3132 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3133 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3134 
    args = requestPickupNumber_args()
3135 
    args.orderId = orderId
4579 rajveer 3136 
    args.providerId = providerId
2536 chandransh 3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_requestPickupNumber(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = requestPickupNumber_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3431 rajveer 3151 
    if result.success is not None:
2536 chandransh 3152 
      return result.success
3431 rajveer 3153 
    if result.ex is not None:
2536 chandransh 3154 
      raise result.ex
3155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3156 
 
4602 rajveer 3157 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3158 
    """
4452 rajveer 3159 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3160 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3161 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3162 
    	3. Returns true
2591 chandransh 3163 
    If the order is in any other status, it returns false.
2536 chandransh 3164 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3165 
 
2536 chandransh 3166 
    Parameters:
3167 
     - orderId
3168 
     - pickupNumber
4602 rajveer 3169 
     - providerId
2536 chandransh 3170 
    """
4602 rajveer 3171 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3172 
    return self.recv_authorizePickup()
3173 
 
4602 rajveer 3174 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3175 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3176 
    args = authorizePickup_args()
3177 
    args.orderId = orderId
3178 
    args.pickupNumber = pickupNumber
4602 rajveer 3179 
    args.providerId = providerId
2536 chandransh 3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_authorizePickup(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = authorizePickup_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3431 rajveer 3194 
    if result.success is not None:
2536 chandransh 3195 
      return result.success
3431 rajveer 3196 
    if result.ex is not None:
2536 chandransh 3197 
      raise result.ex
3198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3199 
 
2764 chandransh 3200 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3201 
    """
3202 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3203 
 
2764 chandransh 3204 
    Parameters:
3205 
     - providerId
3206 
     - pickupDetails
3207 
    """
3208 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3209 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3210 
 
3211 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3212 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3213 
    args = markDoasAsPickedUp_args()
3214 
    args.providerId = providerId
3215 
    args.pickupDetails = pickupDetails
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_markDoasAsPickedUp(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = markDoasAsPickedUp_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
4910 phani.kuma 3230 
    return
3231 
 
3232 
  def getDoasNotPickedUp(self, providerId):
3233 
    """
3234 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3235 
 
3236 
    Parameters:
3237 
     - providerId
3238 
    """
3239 
    self.send_getDoasNotPickedUp(providerId)
3240 
    return self.recv_getDoasNotPickedUp()
3241 
 
3242 
  def send_getDoasNotPickedUp(self, providerId):
3243 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3244 
    args = getDoasNotPickedUp_args()
3245 
    args.providerId = providerId
3246 
    args.write(self._oprot)
3247 
    self._oprot.writeMessageEnd()
3248 
    self._oprot.trans.flush()
3249 
 
3250 
  def recv_getDoasNotPickedUp(self, ):
3251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3252 
    if mtype == TMessageType.EXCEPTION:
3253 
      x = TApplicationException()
3254 
      x.read(self._iprot)
3255 
      self._iprot.readMessageEnd()
3256 
      raise x
3257 
    result = getDoasNotPickedUp_result()
3258 
    result.read(self._iprot)
3259 
    self._iprot.readMessageEnd()
3431 rajveer 3260 
    if result.success is not None:
2764 chandransh 3261 
      return result.success
4910 phani.kuma 3262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3263 
 
4741 phani.kuma 3264 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3265 
    """
3266 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3267 
 
3268 
    Parameters:
3269 
     - providerId
3270 
     - pickupDetails
3271 
    """
3272 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3273 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3274 
 
3275 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3276 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3277 
    args = markReturnOrdersAsPickedUp_args()
3278 
    args.providerId = providerId
3279 
    args.pickupDetails = pickupDetails
3280 
    args.write(self._oprot)
3281 
    self._oprot.writeMessageEnd()
3282 
    self._oprot.trans.flush()
3283 
 
3284 
  def recv_markReturnOrdersAsPickedUp(self, ):
3285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3286 
    if mtype == TMessageType.EXCEPTION:
3287 
      x = TApplicationException()
3288 
      x.read(self._iprot)
3289 
      self._iprot.readMessageEnd()
3290 
      raise x
3291 
    result = markReturnOrdersAsPickedUp_result()
3292 
    result.read(self._iprot)
3293 
    self._iprot.readMessageEnd()
4910 phani.kuma 3294 
    return
3295 
 
3296 
  def getReturnOrdersNotPickedUp(self, providerId):
3297 
    """
3298 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3299 
 
3300 
    Parameters:
3301 
     - providerId
3302 
    """
3303 
    self.send_getReturnOrdersNotPickedUp(providerId)
3304 
    return self.recv_getReturnOrdersNotPickedUp()
3305 
 
3306 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3307 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3308 
    args = getReturnOrdersNotPickedUp_args()
3309 
    args.providerId = providerId
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_getReturnOrdersNotPickedUp(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = getReturnOrdersNotPickedUp_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
4741 phani.kuma 3324 
    if result.success is not None:
3325 
      return result.success
4910 phani.kuma 3326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3327 
 
4479 rajveer 3328 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3329 
    """
4452 rajveer 3330 
    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 3331 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3332 
    If the order is in any other state, it returns false.
3333 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3334 
 
2591 chandransh 3335 
    Parameters:
3336 
     - orderId
4479 rajveer 3337 
     - receiveCondition
2591 chandransh 3338 
    """
4479 rajveer 3339 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3340 
    return self.recv_receiveReturn()
2536 chandransh 3341 
 
4479 rajveer 3342 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3343 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3344 
    args = receiveReturn_args()
2591 chandransh 3345 
    args.orderId = orderId
4479 rajveer 3346 
    args.receiveCondition = receiveCondition
2591 chandransh 3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
2616 chandransh 3351 
  def recv_receiveReturn(self, ):
2591 chandransh 3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
2616 chandransh 3358 
    result = receiveReturn_result()
2591 chandransh 3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3431 rajveer 3361 
    if result.success is not None:
2591 chandransh 3362 
      return result.success
3431 rajveer 3363 
    if result.ex is not None:
2591 chandransh 3364 
      raise result.ex
2616 chandransh 3365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3366 
 
3367 
  def validateDoa(self, orderId, isValid):
3368 
    """
4452 rajveer 3369 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3370 
    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 3371 
    If the order is in any other state, it returns false.
3372 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3373 
 
2591 chandransh 3374 
    Parameters:
3375 
     - orderId
3376 
     - isValid
3377 
    """
3378 
    self.send_validateDoa(orderId, isValid)
3379 
    return self.recv_validateDoa()
3380 
 
3381 
  def send_validateDoa(self, orderId, isValid):
3382 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3383 
    args = validateDoa_args()
3384 
    args.orderId = orderId
3385 
    args.isValid = isValid
3386 
    args.write(self._oprot)
3387 
    self._oprot.writeMessageEnd()
3388 
    self._oprot.trans.flush()
3389 
 
3390 
  def recv_validateDoa(self, ):
3391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3392 
    if mtype == TMessageType.EXCEPTION:
3393 
      x = TApplicationException()
3394 
      x.read(self._iprot)
3395 
      self._iprot.readMessageEnd()
3396 
      raise x
3397 
    result = validateDoa_result()
3398 
    result.read(self._iprot)
3399 
    self._iprot.readMessageEnd()
3431 rajveer 3400 
    if result.success is not None:
2591 chandransh 3401 
      return result.success
3431 rajveer 3402 
    if result.ex is not None:
2591 chandransh 3403 
      raise result.ex
3404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3405 
 
4495 rajveer 3406 
  def validateReturnProduct(self, orderId, isUsable):
3407 
    """
3408 
    Parameters:
3409 
     - orderId
3410 
     - isUsable
3411 
    """
3412 
    self.send_validateReturnProduct(orderId, isUsable)
3413 
    return self.recv_validateReturnProduct()
3414 
 
3415 
  def send_validateReturnProduct(self, orderId, isUsable):
3416 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3417 
    args = validateReturnProduct_args()
3418 
    args.orderId = orderId
3419 
    args.isUsable = isUsable
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_validateReturnProduct(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = validateReturnProduct_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3434 
    if result.success is not None:
3435 
      return result.success
3436 
    if result.ex is not None:
3437 
      raise result.ex
3438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3439 
 
2616 chandransh 3440 
  def reshipOrder(self, orderId):
3441 
    """
4484 rajveer 3442 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3443 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3444 
    	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 3445 
 
3446 
    If the order is in DOA_CERT_VALID state, it does the following:
3447 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3448 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3449 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3450 
 
2616 chandransh 3451 
    Returns the id of the newly created order.
3431 rajveer 3452 
 
2616 chandransh 3453 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3454 
 
2616 chandransh 3455 
    Parameters:
3456 
     - orderId
3457 
    """
3458 
    self.send_reshipOrder(orderId)
3459 
    return self.recv_reshipOrder()
2591 chandransh 3460 
 
2616 chandransh 3461 
  def send_reshipOrder(self, orderId):
3462 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3463 
    args = reshipOrder_args()
3464 
    args.orderId = orderId
3465 
    args.write(self._oprot)
3466 
    self._oprot.writeMessageEnd()
3467 
    self._oprot.trans.flush()
3468 
 
3469 
  def recv_reshipOrder(self, ):
3470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3471 
    if mtype == TMessageType.EXCEPTION:
3472 
      x = TApplicationException()
3473 
      x.read(self._iprot)
3474 
      self._iprot.readMessageEnd()
3475 
      raise x
3476 
    result = reshipOrder_result()
3477 
    result.read(self._iprot)
3478 
    self._iprot.readMessageEnd()
3431 rajveer 3479 
    if result.success is not None:
2616 chandransh 3480 
      return result.success
3431 rajveer 3481 
    if result.ex is not None:
2616 chandransh 3482 
      raise result.ex
3483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3484 
 
3226 chandransh 3485 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3486 
    """
4484 rajveer 3487 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3488 
    	1. Creates a refund request for batch processing.
3489 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3490 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3491 
 
2616 chandransh 3492 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3493 
    	1. Creates a refund request for batch processing.
3226 chandransh 3494 
    	2. Cancels the reservation of the item in the warehouse.
3495 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3496 
 
3226 chandransh 3497 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3498 
    	1. Cancels the reservation of the item in the warehouse.
3499 
    	2. Marks the current order as CANCELED.
3500 
 
3501 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3502 
 
2616 chandransh 3503 
    Returns True if it is successful, False otherwise.
3431 rajveer 3504 
 
2616 chandransh 3505 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3506 
 
2616 chandransh 3507 
    Parameters:
3508 
     - orderId
3226 chandransh 3509 
     - refundedBy
3510 
     - reason
2616 chandransh 3511 
    """
3226 chandransh 3512 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3513 
    return self.recv_refundOrder()
3514 
 
3226 chandransh 3515 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3516 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3517 
    args = refundOrder_args()
3518 
    args.orderId = orderId
3226 chandransh 3519 
    args.refundedBy = refundedBy
3520 
    args.reason = reason
2616 chandransh 3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_refundOrder(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = refundOrder_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3431 rajveer 3535 
    if result.success is not None:
2616 chandransh 3536 
      return result.success
3431 rajveer 3537 
    if result.ex is not None:
2616 chandransh 3538 
      raise result.ex
3539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3540 
 
2690 chandransh 3541 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3542 
    """
3543 
    Get all return orders created between the from and to dates for the given warehouse.
3544 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3545 
 
2690 chandransh 3546 
    Parameters:
3547 
     - warehouseId
3548 
     - fromDate
3549 
     - toDate
3550 
    """
3551 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3552 
    return self.recv_getReturnOrders()
2616 chandransh 3553 
 
2690 chandransh 3554 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3555 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3556 
    args = getReturnOrders_args()
3557 
    args.warehouseId = warehouseId
3558 
    args.fromDate = fromDate
3559 
    args.toDate = toDate
3560 
    args.write(self._oprot)
3561 
    self._oprot.writeMessageEnd()
3562 
    self._oprot.trans.flush()
3563 
 
3564 
  def recv_getReturnOrders(self, ):
3565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3566 
    if mtype == TMessageType.EXCEPTION:
3567 
      x = TApplicationException()
3568 
      x.read(self._iprot)
3569 
      self._iprot.readMessageEnd()
3570 
      raise x
3571 
    result = getReturnOrders_result()
3572 
    result.read(self._iprot)
3573 
    self._iprot.readMessageEnd()
3431 rajveer 3574 
    if result.success is not None:
2690 chandransh 3575 
      return result.success
3576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3577 
 
2700 chandransh 3578 
  def getReturnOrder(self, id):
3579 
    """
3580 
    Returns the ReturnOrder corresponding to the given id.
3581 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3582 
 
2700 chandransh 3583 
    Parameters:
3584 
     - id
3585 
    """
3586 
    self.send_getReturnOrder(id)
3587 
    return self.recv_getReturnOrder()
3588 
 
3589 
  def send_getReturnOrder(self, id):
3590 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3591 
    args = getReturnOrder_args()
3592 
    args.id = id
3593 
    args.write(self._oprot)
3594 
    self._oprot.writeMessageEnd()
3595 
    self._oprot.trans.flush()
3596 
 
3597 
  def recv_getReturnOrder(self, ):
3598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3599 
    if mtype == TMessageType.EXCEPTION:
3600 
      x = TApplicationException()
3601 
      x.read(self._iprot)
3602 
      self._iprot.readMessageEnd()
3603 
      raise x
3604 
    result = getReturnOrder_result()
3605 
    result.read(self._iprot)
3606 
    self._iprot.readMessageEnd()
3431 rajveer 3607 
    if result.success is not None:
2700 chandransh 3608 
      return result.success
3431 rajveer 3609 
    if result.ex is not None:
2700 chandransh 3610 
      raise result.ex
3611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3612 
 
2690 chandransh 3613 
  def processReturn(self, returnOrderId):
3614 
    """
3615 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3616 
 
2690 chandransh 3617 
    Parameters:
3618 
     - returnOrderId
3619 
    """
3620 
    self.send_processReturn(returnOrderId)
3621 
    self.recv_processReturn()
3622 
 
3623 
  def send_processReturn(self, returnOrderId):
3624 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3625 
    args = processReturn_args()
3626 
    args.returnOrderId = returnOrderId
3627 
    args.write(self._oprot)
3628 
    self._oprot.writeMessageEnd()
3629 
    self._oprot.trans.flush()
3630 
 
3631 
  def recv_processReturn(self, ):
3632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3633 
    if mtype == TMessageType.EXCEPTION:
3634 
      x = TApplicationException()
3635 
      x.read(self._iprot)
3636 
      self._iprot.readMessageEnd()
3637 
      raise x
3638 
    result = processReturn_result()
3639 
    result.read(self._iprot)
3640 
    self._iprot.readMessageEnd()
3431 rajveer 3641 
    if result.ex is not None:
2690 chandransh 3642 
      raise result.ex
3643 
    return
3644 
 
3451 chandransh 3645 
  def updateWeight(self, orderId, weight):
3646 
    """
3647 
    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 3648 
 
3451 chandransh 3649 
    Parameters:
3650 
     - orderId
3651 
     - weight
3652 
    """
3653 
    self.send_updateWeight(orderId, weight)
3654 
    return self.recv_updateWeight()
3655 
 
3656 
  def send_updateWeight(self, orderId, weight):
3657 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3658 
    args = updateWeight_args()
3659 
    args.orderId = orderId
3660 
    args.weight = weight
3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_updateWeight(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = updateWeight_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3675 
    if result.success is not None:
3676 
      return result.success
3677 
    if result.ex is not None:
3678 
      raise result.ex
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3680 
 
3469 chandransh 3681 
  def changeItem(self, orderId, itemId):
3682 
    """
3683 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3684 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3685 
 
3469 chandransh 3686 
    Parameters:
3687 
     - orderId
3688 
     - itemId
3689 
    """
3690 
    self.send_changeItem(orderId, itemId)
3691 
    return self.recv_changeItem()
3692 
 
3693 
  def send_changeItem(self, orderId, itemId):
3694 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3695 
    args = changeItem_args()
3696 
    args.orderId = orderId
3697 
    args.itemId = itemId
3698 
    args.write(self._oprot)
3699 
    self._oprot.writeMessageEnd()
3700 
    self._oprot.trans.flush()
3701 
 
3702 
  def recv_changeItem(self, ):
3703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3704 
    if mtype == TMessageType.EXCEPTION:
3705 
      x = TApplicationException()
3706 
      x.read(self._iprot)
3707 
      self._iprot.readMessageEnd()
3708 
      raise x
3709 
    result = changeItem_result()
3710 
    result.read(self._iprot)
3711 
    self._iprot.readMessageEnd()
3712 
    if result.success is not None:
3713 
      return result.success
3714 
    if result.ex is not None:
3715 
      raise result.ex
3716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3717 
 
3718 
  def shiftToWarehouse(self, orderId, warehouseId):
3719 
    """
3720 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3721 
 
3722 
    Parameters:
3723 
     - orderId
3724 
     - warehouseId
3725 
    """
3726 
    self.send_shiftToWarehouse(orderId, warehouseId)
3727 
    return self.recv_shiftToWarehouse()
3728 
 
3729 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3730 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3731 
    args = shiftToWarehouse_args()
3732 
    args.orderId = orderId
3733 
    args.warehouseId = warehouseId
3734 
    args.write(self._oprot)
3735 
    self._oprot.writeMessageEnd()
3736 
    self._oprot.trans.flush()
3737 
 
3738 
  def recv_shiftToWarehouse(self, ):
3739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3740 
    if mtype == TMessageType.EXCEPTION:
3741 
      x = TApplicationException()
3742 
      x.read(self._iprot)
3743 
      self._iprot.readMessageEnd()
3744 
      raise x
3745 
    result = shiftToWarehouse_result()
3746 
    result.read(self._iprot)
3747 
    self._iprot.readMessageEnd()
3748 
    if result.success is not None:
3749 
      return result.success
3750 
    if result.ex is not None:
3751 
      raise result.ex
3752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3753 
 
4647 rajveer 3754 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3755 
    """
3756 
    Adds the given delay reason to the given order.
3986 chandransh 3757 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3758 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3759 
 
3553 chandransh 3760 
    Parameters:
3761 
     - orderId
3762 
     - delayReason
3986 chandransh 3763 
     - furtherDelay
4647 rajveer 3764 
     - delayReasonText
3553 chandransh 3765 
    """
4647 rajveer 3766 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3767 
    return self.recv_addDelayReason()
3768 
 
4647 rajveer 3769 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3770 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3771 
    args = addDelayReason_args()
3772 
    args.orderId = orderId
3773 
    args.delayReason = delayReason
3986 chandransh 3774 
    args.furtherDelay = furtherDelay
4647 rajveer 3775 
    args.delayReasonText = delayReasonText
3553 chandransh 3776 
    args.write(self._oprot)
3777 
    self._oprot.writeMessageEnd()
3778 
    self._oprot.trans.flush()
3779 
 
3780 
  def recv_addDelayReason(self, ):
3781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3782 
    if mtype == TMessageType.EXCEPTION:
3783 
      x = TApplicationException()
3784 
      x.read(self._iprot)
3785 
      self._iprot.readMessageEnd()
3786 
      raise x
3787 
    result = addDelayReason_result()
3788 
    result.read(self._iprot)
3789 
    self._iprot.readMessageEnd()
3790 
    if result.success is not None:
3791 
      return result.success
3792 
    if result.ex is not None:
3793 
      raise result.ex
3794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3795 
 
3956 chandransh 3796 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3797 
    """
3798 
    Marks the COD orders with given AWB nos. as having been processed.
3799 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3800 
 
3956 chandransh 3801 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3802 
    1. There is no order corresponding to an AWB number.
3803 
    2. The captured amount for a payment exceeds the total payment.
3804 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3805 
 
3806 
    Parameters:
3807 
     - collectedAmountMap
3808 
     - xferBy
3809 
     - xferTxnId
3810 
     - xferDate
3811 
    """
3812 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3813 
    return self.recv_reconcileCodCollection()
3814 
 
3815 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3816 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3817 
    args = reconcileCodCollection_args()
3818 
    args.collectedAmountMap = collectedAmountMap
3819 
    args.xferBy = xferBy
3820 
    args.xferTxnId = xferTxnId
3821 
    args.xferDate = xferDate
3822 
    args.write(self._oprot)
3823 
    self._oprot.writeMessageEnd()
3824 
    self._oprot.trans.flush()
3825 
 
3826 
  def recv_reconcileCodCollection(self, ):
3827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3828 
    if mtype == TMessageType.EXCEPTION:
3829 
      x = TApplicationException()
3830 
      x.read(self._iprot)
3831 
      self._iprot.readMessageEnd()
3832 
      raise x
3833 
    result = reconcileCodCollection_result()
3834 
    result.read(self._iprot)
3835 
    self._iprot.readMessageEnd()
3836 
    if result.success is not None:
3837 
      return result.success
3838 
    if result.ex is not None:
3839 
      raise result.ex
3840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3841 
 
4008 mandeep.dh 3842 
  def getTransactionsRequiringExtraProcessing(self, category):
3843 
    """
4065 mandeep.dh 3844 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3845 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3846 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3847 
 
4008 mandeep.dh 3848 
    Parameters:
3849 
     - category
3850 
    """
3851 
    self.send_getTransactionsRequiringExtraProcessing(category)
3852 
    return self.recv_getTransactionsRequiringExtraProcessing()
3853 
 
3854 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3855 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3856 
    args = getTransactionsRequiringExtraProcessing_args()
3857 
    args.category = category
3858 
    args.write(self._oprot)
3859 
    self._oprot.writeMessageEnd()
3860 
    self._oprot.trans.flush()
3861 
 
3862 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3864 
    if mtype == TMessageType.EXCEPTION:
3865 
      x = TApplicationException()
3866 
      x.read(self._iprot)
3867 
      self._iprot.readMessageEnd()
3868 
      raise x
3869 
    result = getTransactionsRequiringExtraProcessing_result()
3870 
    result.read(self._iprot)
3871 
    self._iprot.readMessageEnd()
3872 
    if result.success is not None:
3873 
      return result.success
3874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3875 
 
3876 
  def markTransactionAsProcessed(self, transactionId, category):
3877 
    """
3878 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3879 
    It essentially deletes the transaction id record for a particular
3880 
    processing type category (if present) from DB.
3881 
    This is currently used by CRM application.
4008 mandeep.dh 3882 
 
3883 
    Parameters:
3884 
     - transactionId
3885 
     - category
3886 
    """
3887 
    self.send_markTransactionAsProcessed(transactionId, category)
3888 
    self.recv_markTransactionAsProcessed()
3889 
 
3890 
  def send_markTransactionAsProcessed(self, transactionId, category):
3891 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3892 
    args = markTransactionAsProcessed_args()
3893 
    args.transactionId = transactionId
3894 
    args.category = category
3895 
    args.write(self._oprot)
3896 
    self._oprot.writeMessageEnd()
3897 
    self._oprot.trans.flush()
3898 
 
3899 
  def recv_markTransactionAsProcessed(self, ):
3900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3901 
    if mtype == TMessageType.EXCEPTION:
3902 
      x = TApplicationException()
3903 
      x.read(self._iprot)
3904 
      self._iprot.readMessageEnd()
3905 
      raise x
3906 
    result = markTransactionAsProcessed_result()
3907 
    result.read(self._iprot)
3908 
    self._iprot.readMessageEnd()
3909 
    return
3910 
 
4018 chandransh 3911 
  def getItemWiseRiskyOrdersCount(self, ):
3912 
    """
3913 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3914 
    is defined as one whose shipping date is about to expire.
3915 
    """
3916 
    self.send_getItemWiseRiskyOrdersCount()
3917 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3918 
 
4018 chandransh 3919 
  def send_getItemWiseRiskyOrdersCount(self, ):
3920 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3921 
    args = getItemWiseRiskyOrdersCount_args()
3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = getItemWiseRiskyOrdersCount_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3936 
    if result.success is not None:
3937 
      return result.success
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3939 
 
4295 varun.gupt 3940 
  def getOrdersForItemIds(self, itemIds):
3941 
    """
3942 
    Returns a list of all orders which have items with given id
3943 
 
3944 
    Parameters:
3945 
     - itemIds
3946 
    """
3947 
    self.send_getOrdersForItemIds(itemIds)
3948 
    return self.recv_getOrdersForItemIds()
3949 
 
3950 
  def send_getOrdersForItemIds(self, itemIds):
3951 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3952 
    args = getOrdersForItemIds_args()
3953 
    args.itemIds = itemIds
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_getOrdersForItemIds(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = getOrdersForItemIds_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3968 
    if result.success is not None:
3969 
      return result.success
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3971 
 
4247 rajveer 3972 
  def markOrderCancellationRequestReceived(self, orderId):
3973 
    """
3974 
    Mark order as cancellation request received. If customer sends request of cancellation of
3975 
    a particular order, this method will be called. It will just change status of the order
3976 
    depending on its current status. It also records the previous status, so that we can move
3977 
    back to that status if cancellation request is denied.
4018 chandransh 3978 
 
4247 rajveer 3979 
    Parameters:
3980 
     - orderId
3981 
    """
3982 
    self.send_markOrderCancellationRequestReceived(orderId)
3983 
    self.recv_markOrderCancellationRequestReceived()
3984 
 
3985 
  def send_markOrderCancellationRequestReceived(self, orderId):
3986 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3987 
    args = markOrderCancellationRequestReceived_args()
3988 
    args.orderId = orderId
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_markOrderCancellationRequestReceived(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = markOrderCancellationRequestReceived_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    if result.ex is not None:
4004 
      raise result.ex
4005 
    return
4006 
 
4007 
  def markOrderCancellationRequestConfirmed(self, orderId):
4008 
    """
4009 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4010 
    cancellation request confirmed. After this OM will be able to cancel the order.
4011 
 
4012 
    Parameters:
4013 
     - orderId
4014 
    """
4015 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4016 
    self.recv_markOrderCancellationRequestConfirmed()
4017 
 
4018 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4019 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4020 
    args = markOrderCancellationRequestConfirmed_args()
4021 
    args.orderId = orderId
4022 
    args.write(self._oprot)
4023 
    self._oprot.writeMessageEnd()
4024 
    self._oprot.trans.flush()
4025 
 
4026 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4028 
    if mtype == TMessageType.EXCEPTION:
4029 
      x = TApplicationException()
4030 
      x.read(self._iprot)
4031 
      self._iprot.readMessageEnd()
4032 
      raise x
4033 
    result = markOrderCancellationRequestConfirmed_result()
4034 
    result.read(self._iprot)
4035 
    self._iprot.readMessageEnd()
4036 
    if result.ex is not None:
4037 
      raise result.ex
4038 
    return
4039 
 
4040 
  def markOrderCancellationRequestDenied(self, orderId):
4041 
    """
4042 
    If we decide to not to cancel order, we will move the order ro previous status.
4043 
 
4044 
    Parameters:
4045 
     - orderId
4046 
    """
4047 
    self.send_markOrderCancellationRequestDenied(orderId)
4048 
    self.recv_markOrderCancellationRequestDenied()
4049 
 
4050 
  def send_markOrderCancellationRequestDenied(self, orderId):
4051 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4052 
    args = markOrderCancellationRequestDenied_args()
4053 
    args.orderId = orderId
4054 
    args.write(self._oprot)
4055 
    self._oprot.writeMessageEnd()
4056 
    self._oprot.trans.flush()
4057 
 
4058 
  def recv_markOrderCancellationRequestDenied(self, ):
4059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4060 
    if mtype == TMessageType.EXCEPTION:
4061 
      x = TApplicationException()
4062 
      x.read(self._iprot)
4063 
      self._iprot.readMessageEnd()
4064 
      raise x
4065 
    result = markOrderCancellationRequestDenied_result()
4066 
    result.read(self._iprot)
4067 
    self._iprot.readMessageEnd()
4068 
    if result.ex is not None:
4069 
      raise result.ex
4070 
    return
4071 
 
4258 rajveer 4072 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4073 
    """
4258 rajveer 4074 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4075 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4076 
 
4077 
    Parameters:
4258 rajveer 4078 
     - transactionId
4247 rajveer 4079 
    """
4258 rajveer 4080 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4081 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4082 
 
4258 rajveer 4083 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4084 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4085 
    args = markTransactionAsPaymentFlagRemoved_args()
4086 
    args.transactionId = transactionId
4247 rajveer 4087 
    args.write(self._oprot)
4088 
    self._oprot.writeMessageEnd()
4089 
    self._oprot.trans.flush()
4090 
 
4258 rajveer 4091 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4093 
    if mtype == TMessageType.EXCEPTION:
4094 
      x = TApplicationException()
4095 
      x.read(self._iprot)
4096 
      self._iprot.readMessageEnd()
4097 
      raise x
4258 rajveer 4098 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4099 
    result.read(self._iprot)
4100 
    self._iprot.readMessageEnd()
4101 
    if result.ex is not None:
4102 
      raise result.ex
4103 
    return
4104 
 
4259 anupam.sin 4105 
  def refundTransaction(self, transactionId, refundedBy, reason):
4106 
    """
4107 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4108 
    need to be cancelled
4247 rajveer 4109 
 
4259 anupam.sin 4110 
    Parameters:
4111 
     - transactionId
4112 
     - refundedBy
4113 
     - reason
4114 
    """
4115 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4116 
    self.recv_refundTransaction()
4117 
 
4118 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4119 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4120 
    args = refundTransaction_args()
4121 
    args.transactionId = transactionId
4122 
    args.refundedBy = refundedBy
4123 
    args.reason = reason
4124 
    args.write(self._oprot)
4125 
    self._oprot.writeMessageEnd()
4126 
    self._oprot.trans.flush()
4127 
 
4128 
  def recv_refundTransaction(self, ):
4129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4130 
    if mtype == TMessageType.EXCEPTION:
4131 
      x = TApplicationException()
4132 
      x.read(self._iprot)
4133 
      self._iprot.readMessageEnd()
4134 
      raise x
4135 
    result = refundTransaction_result()
4136 
    result.read(self._iprot)
4137 
    self._iprot.readMessageEnd()
4138 
    if result.ex is not None:
4139 
      raise result.ex
4140 
    return
4141 
 
4324 mandeep.dh 4142 
  def updateShipmentAddress(self, orderId, addressId):
4143 
    """
4144 
    Updates shipment address of an order. Delivery and shipping date estimates
4145 
    etc. are also updated here.
4146 
 
4147 
    Throws TransactionServiceException in case address change is not
4148 
    possible due to certain reasons such as new pincode in address is
4149 
    not serviceable etc.
4150 
 
4151 
    Parameters:
4152 
     - orderId
4153 
     - addressId
4154 
    """
4155 
    self.send_updateShipmentAddress(orderId, addressId)
4156 
    self.recv_updateShipmentAddress()
4157 
 
4158 
  def send_updateShipmentAddress(self, orderId, addressId):
4159 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4160 
    args = updateShipmentAddress_args()
4161 
    args.orderId = orderId
4162 
    args.addressId = addressId
4163 
    args.write(self._oprot)
4164 
    self._oprot.writeMessageEnd()
4165 
    self._oprot.trans.flush()
4166 
 
4167 
  def recv_updateShipmentAddress(self, ):
4168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4169 
    if mtype == TMessageType.EXCEPTION:
4170 
      x = TApplicationException()
4171 
      x.read(self._iprot)
4172 
      self._iprot.readMessageEnd()
4173 
      raise x
4174 
    result = updateShipmentAddress_result()
4175 
    result.read(self._iprot)
4176 
    self._iprot.readMessageEnd()
4177 
    if result.ex is not None:
4178 
      raise result.ex
4179 
    return
4180 
 
4285 rajveer 4181 
  def acceptOrdersForItemId(self, itemId, inventory):
4182 
    """
4183 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4184 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4185 
 
4285 rajveer 4186 
    Parameters:
4187 
     - itemId
4188 
     - inventory
4189 
    """
4190 
    self.send_acceptOrdersForItemId(itemId, inventory)
4191 
    return self.recv_acceptOrdersForItemId()
4192 
 
4193 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4194 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4195 
    args = acceptOrdersForItemId_args()
4196 
    args.itemId = itemId
4197 
    args.inventory = inventory
4198 
    args.write(self._oprot)
4199 
    self._oprot.writeMessageEnd()
4200 
    self._oprot.trans.flush()
4201 
 
4202 
  def recv_acceptOrdersForItemId(self, ):
4203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4204 
    if mtype == TMessageType.EXCEPTION:
4205 
      x = TApplicationException()
4206 
      x.read(self._iprot)
4207 
      self._iprot.readMessageEnd()
4208 
      raise x
4209 
    result = acceptOrdersForItemId_result()
4210 
    result.read(self._iprot)
4211 
    self._iprot.readMessageEnd()
4212 
    if result.success is not None:
4213 
      return result.success
4214 
    if result.ex is not None:
4215 
      raise result.ex
4216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4217 
 
4369 rajveer 4218 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4219 
    """
4220 
    Parameters:
4221 
     - vendorId
4222 
     - itemId
4223 
     - quantity
4224 
     - estimate
4369 rajveer 4225 
     - isReminder
4303 rajveer 4226 
    """
4369 rajveer 4227 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4228 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4229 
 
4369 rajveer 4230 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4231 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4232 
    args = markOrdersAsPORaised_args()
4233 
    args.vendorId = vendorId
4234 
    args.itemId = itemId
4235 
    args.quantity = quantity
4236 
    args.estimate = estimate
4369 rajveer 4237 
    args.isReminder = isReminder
4303 rajveer 4238 
    args.write(self._oprot)
4239 
    self._oprot.writeMessageEnd()
4240 
    self._oprot.trans.flush()
4241 
 
4242 
  def recv_markOrdersAsPORaised(self, ):
4243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4244 
    if mtype == TMessageType.EXCEPTION:
4245 
      x = TApplicationException()
4246 
      x.read(self._iprot)
4247 
      self._iprot.readMessageEnd()
4248 
      raise x
4249 
    result = markOrdersAsPORaised_result()
4250 
    result.read(self._iprot)
4251 
    self._iprot.readMessageEnd()
4252 
    if result.ex is not None:
4253 
      raise result.ex
4254 
    return
4255 
 
4369 rajveer 4256 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4257 
    """
4258 
    Parameters:
4259 
     - vendorId
4260 
     - itemId
4261 
     - quantity
4262 
     - estimate
4369 rajveer 4263 
     - isReminder
4303 rajveer 4264 
    """
4369 rajveer 4265 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4266 
    self.recv_markOrdersAsReversalInitiated()
4267 
 
4369 rajveer 4268 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4269 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4270 
    args = markOrdersAsReversalInitiated_args()
4271 
    args.vendorId = vendorId
4272 
    args.itemId = itemId
4273 
    args.quantity = quantity
4274 
    args.estimate = estimate
4369 rajveer 4275 
    args.isReminder = isReminder
4303 rajveer 4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_markOrdersAsReversalInitiated(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = markOrdersAsReversalInitiated_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.ex is not None:
4291 
      raise result.ex
4292 
    return
4293 
 
4369 rajveer 4294 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4295 
    """
4296 
    Parameters:
4297 
     - vendorId
4298 
     - itemId
4299 
     - quantity
4300 
     - estimate
4369 rajveer 4301 
     - isReminder
4303 rajveer 4302 
    """
4369 rajveer 4303 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4304 
    self.recv_markOrdersAsNotAvailabke()
4305 
 
4369 rajveer 4306 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4307 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4308 
    args = markOrdersAsNotAvailabke_args()
4309 
    args.vendorId = vendorId
4310 
    args.itemId = itemId
4311 
    args.quantity = quantity
4312 
    args.estimate = estimate
4369 rajveer 4313 
    args.isReminder = isReminder
4303 rajveer 4314 
    args.write(self._oprot)
4315 
    self._oprot.writeMessageEnd()
4316 
    self._oprot.trans.flush()
4317 
 
4318 
  def recv_markOrdersAsNotAvailabke(self, ):
4319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4320 
    if mtype == TMessageType.EXCEPTION:
4321 
      x = TApplicationException()
4322 
      x.read(self._iprot)
4323 
      self._iprot.readMessageEnd()
4324 
      raise x
4325 
    result = markOrdersAsNotAvailabke_result()
4326 
    result.read(self._iprot)
4327 
    self._iprot.readMessageEnd()
4328 
    if result.ex is not None:
4329 
      raise result.ex
4330 
    return
4331 
 
4369 rajveer 4332 
  def markOrdersAsTimeout(self, vendorId):
4333 
    """
4334 
    Parameters:
4335 
     - vendorId
4336 
    """
4337 
    self.send_markOrdersAsTimeout(vendorId)
4338 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4339 
 
4369 rajveer 4340 
  def send_markOrdersAsTimeout(self, vendorId):
4341 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4342 
    args = markOrdersAsTimeout_args()
4343 
    args.vendorId = vendorId
4344 
    args.write(self._oprot)
4345 
    self._oprot.writeMessageEnd()
4346 
    self._oprot.trans.flush()
4347 
 
4348 
  def recv_markOrdersAsTimeout(self, ):
4349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4350 
    if mtype == TMessageType.EXCEPTION:
4351 
      x = TApplicationException()
4352 
      x.read(self._iprot)
4353 
      self._iprot.readMessageEnd()
4354 
      raise x
4355 
    result = markOrdersAsTimeout_result()
4356 
    result.read(self._iprot)
4357 
    self._iprot.readMessageEnd()
4358 
    if result.success is not None:
4359 
      return result.success
4360 
    if result.ex is not None:
4361 
      raise result.ex
4362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4363 
 
4662 rajveer 4364 
  def markOrderAsLostInTransit(self, orderId):
4365 
    """
4366 
    Mark order as LOST_IN_TRANSIT
4367 
 
4368 
    Parameters:
4369 
     - orderId
4370 
    """
4371 
    self.send_markOrderAsLostInTransit(orderId)
4372 
    return self.recv_markOrderAsLostInTransit()
4373 
 
4374 
  def send_markOrderAsLostInTransit(self, orderId):
4375 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4376 
    args = markOrderAsLostInTransit_args()
4377 
    args.orderId = orderId
4378 
    args.write(self._oprot)
4379 
    self._oprot.writeMessageEnd()
4380 
    self._oprot.trans.flush()
4381 
 
4382 
  def recv_markOrderAsLostInTransit(self, ):
4383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4384 
    if mtype == TMessageType.EXCEPTION:
4385 
      x = TApplicationException()
4386 
      x.read(self._iprot)
4387 
      self._iprot.readMessageEnd()
4388 
      raise x
4389 
    result = markOrderAsLostInTransit_result()
4390 
    result.read(self._iprot)
4391 
    self._iprot.readMessageEnd()
4392 
    if result.success is not None:
4393 
      return result.success
4394 
    if result.ex is not None:
4395 
      raise result.ex
4396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4397 
 
4386 anupam.sin 4398 
  def getOrderForAwb(self, awb):
4399 
    """
4400 
    Returns the order corresponding to an AWB number
4369 rajveer 4401 
 
4386 anupam.sin 4402 
    Parameters:
4403 
     - awb
4404 
    """
4405 
    self.send_getOrderForAwb(awb)
4406 
    return self.recv_getOrderForAwb()
4407 
 
4408 
  def send_getOrderForAwb(self, awb):
4409 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4410 
    args = getOrderForAwb_args()
4411 
    args.awb = awb
4412 
    args.write(self._oprot)
4413 
    self._oprot.writeMessageEnd()
4414 
    self._oprot.trans.flush()
4415 
 
4416 
  def recv_getOrderForAwb(self, ):
4417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4418 
    if mtype == TMessageType.EXCEPTION:
4419 
      x = TApplicationException()
4420 
      x.read(self._iprot)
4421 
      self._iprot.readMessageEnd()
4422 
      raise x
4423 
    result = getOrderForAwb_result()
4424 
    result.read(self._iprot)
4425 
    self._iprot.readMessageEnd()
4426 
    if result.success is not None:
4427 
      return result.success
4428 
    if result.ex is not None:
4429 
      raise result.ex
4430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4431 
 
4910 phani.kuma 4432 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4433 
    """
4910 phani.kuma 4434 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4435 
 
4506 phani.kuma 4436 
    Parameters:
4437 
     - logistics_provider_id
4910 phani.kuma 4438 
     - order_status_list
4506 phani.kuma 4439 
    """
4910 phani.kuma 4440 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4441 
    return self.recv_getOrdersForProviderForStatus()
4442 
 
4910 phani.kuma 4443 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4444 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4445 
    args = getOrdersForProviderForStatus_args()
4446 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4447 
    args.order_status_list = order_status_list
4506 phani.kuma 4448 
    args.write(self._oprot)
4449 
    self._oprot.writeMessageEnd()
4450 
    self._oprot.trans.flush()
4451 
 
4452 
  def recv_getOrdersForProviderForStatus(self, ):
4453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4454 
    if mtype == TMessageType.EXCEPTION:
4455 
      x = TApplicationException()
4456 
      x.read(self._iprot)
4457 
      self._iprot.readMessageEnd()
4458 
      raise x
4459 
    result = getOrdersForProviderForStatus_result()
4460 
    result.read(self._iprot)
4461 
    self._iprot.readMessageEnd()
4462 
    if result.success is not None:
4463 
      return result.success
4464 
    if result.ex is not None:
4465 
      raise result.ex
4466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4467 
 
4600 varun.gupt 4468 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4469 
    """
4470 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4471 
 
4600 varun.gupt 4472 
    Parameters:
4473 
     - vendorId
4474 
     - billingDateFrom
4475 
     - billingDateTo
4476 
    """
4477 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4478 
    return self.recv_getBilledOrdersForVendor()
4479 
 
4480 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4481 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4482 
    args = getBilledOrdersForVendor_args()
4483 
    args.vendorId = vendorId
4484 
    args.billingDateFrom = billingDateFrom
4485 
    args.billingDateTo = billingDateTo
4486 
    args.write(self._oprot)
4487 
    self._oprot.writeMessageEnd()
4488 
    self._oprot.trans.flush()
4489 
 
4490 
  def recv_getBilledOrdersForVendor(self, ):
4491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4492 
    if mtype == TMessageType.EXCEPTION:
4493 
      x = TApplicationException()
4494 
      x.read(self._iprot)
4495 
      self._iprot.readMessageEnd()
4496 
      raise x
4497 
    result = getBilledOrdersForVendor_result()
4498 
    result.read(self._iprot)
4499 
    self._iprot.readMessageEnd()
4500 
    if result.success is not None:
4501 
      return result.success
4502 
    if result.ex is not None:
4503 
      raise result.ex
4504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4505 
 
4607 rajveer 4506 
  def getSlippedSippingDateOrders(self, ):
4507 
    self.send_getSlippedSippingDateOrders()
4508 
    return self.recv_getSlippedSippingDateOrders()
4509 
 
4510 
  def send_getSlippedSippingDateOrders(self, ):
4511 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4512 
    args = getSlippedSippingDateOrders_args()
4513 
    args.write(self._oprot)
4514 
    self._oprot.writeMessageEnd()
4515 
    self._oprot.trans.flush()
4516 
 
4517 
  def recv_getSlippedSippingDateOrders(self, ):
4518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4519 
    if mtype == TMessageType.EXCEPTION:
4520 
      x = TApplicationException()
4521 
      x.read(self._iprot)
4522 
      self._iprot.readMessageEnd()
4523 
      raise x
4524 
    result = getSlippedSippingDateOrders_result()
4525 
    result.read(self._iprot)
4526 
    self._iprot.readMessageEnd()
4527 
    if result.success is not None:
4528 
      return result.success
4529 
    if result.ex is not None:
4530 
      raise result.ex
4531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4532 
 
4709 rajveer 4533 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4534 
    """
4535 
    Parameters:
4536 
     - cancelDateFrom
4537 
     - cancelDateTo
4538 
    """
4539 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4540 
    return self.recv_getCancelledOrders()
4541 
 
4542 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4543 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4544 
    args = getCancelledOrders_args()
4545 
    args.cancelDateFrom = cancelDateFrom
4546 
    args.cancelDateTo = cancelDateTo
4547 
    args.write(self._oprot)
4548 
    self._oprot.writeMessageEnd()
4549 
    self._oprot.trans.flush()
4550 
 
4551 
  def recv_getCancelledOrders(self, ):
4552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4553 
    if mtype == TMessageType.EXCEPTION:
4554 
      x = TApplicationException()
4555 
      x.read(self._iprot)
4556 
      self._iprot.readMessageEnd()
4557 
      raise x
4558 
    result = getCancelledOrders_result()
4559 
    result.read(self._iprot)
4560 
    self._iprot.readMessageEnd()
4561 
    if result.success is not None:
4562 
      return result.success
4563 
    if result.ex is not None:
4564 
      raise result.ex
4565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4566 
 
4600 varun.gupt 4567 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4568 
    """
4569 
    Parameters:
4570 
     - mapAWBAndAmount
4571 
    """
4572 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4573 
    self.recv_saveBluedartSettlements()
4574 
 
4575 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4576 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4577 
    args = saveBluedartSettlements_args()
4578 
    args.mapAWBAndAmount = mapAWBAndAmount
4579 
    args.write(self._oprot)
4580 
    self._oprot.writeMessageEnd()
4581 
    self._oprot.trans.flush()
4582 
 
4583 
  def recv_saveBluedartSettlements(self, ):
4584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4585 
    if mtype == TMessageType.EXCEPTION:
4586 
      x = TApplicationException()
4587 
      x.read(self._iprot)
4588 
      self._iprot.readMessageEnd()
4589 
      raise x
4590 
    result = saveBluedartSettlements_result()
4591 
    result.read(self._iprot)
4592 
    self._iprot.readMessageEnd()
4593 
    if result.ex is not None:
4594 
      raise result.ex
4595 
    return
4596 
 
4905 varun.gupt 4597 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4598 
    """
4599 
    Parameters:
4600 
     - settlementDate
4601 
     - paymentGatewayId
4905 varun.gupt 4602 
     - referenceId
4600 varun.gupt 4603 
     - serviceTax
4604 
     - otherCharges
4605 
     - netCollection
4606 
    """
4905 varun.gupt 4607 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4608 
    self.recv_savePaymentSettlements()
4609 
 
4905 varun.gupt 4610 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4611 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4612 
    args = savePaymentSettlements_args()
4613 
    args.settlementDate = settlementDate
4614 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4615 
    args.referenceId = referenceId
4600 varun.gupt 4616 
    args.serviceTax = serviceTax
4617 
    args.otherCharges = otherCharges
4618 
    args.netCollection = netCollection
4619 
    args.write(self._oprot)
4620 
    self._oprot.writeMessageEnd()
4621 
    self._oprot.trans.flush()
4622 
 
4623 
  def recv_savePaymentSettlements(self, ):
4624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4625 
    if mtype == TMessageType.EXCEPTION:
4626 
      x = TApplicationException()
4627 
      x.read(self._iprot)
4628 
      self._iprot.readMessageEnd()
4629 
      raise x
4630 
    result = savePaymentSettlements_result()
4631 
    result.read(self._iprot)
4632 
    self._iprot.readMessageEnd()
4633 
    if result.ex is not None:
4634 
      raise result.ex
4635 
    return
4636 
 
4637 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4638 
    """
4639 
    Parameters:
4640 
     - settlementId
4641 
     - settlementDate
4642 
     - transactionDateFrom
4643 
     - transactionDateTo
4644 
     - amount
4645 
    """
4646 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4647 
    self.recv_saveEBSSettlementSummary()
4648 
 
4649 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4650 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4651 
    args = saveEBSSettlementSummary_args()
4652 
    args.settlementId = settlementId
4653 
    args.settlementDate = settlementDate
4654 
    args.transactionDateFrom = transactionDateFrom
4655 
    args.transactionDateTo = transactionDateTo
4656 
    args.amount = amount
4657 
    args.write(self._oprot)
4658 
    self._oprot.writeMessageEnd()
4659 
    self._oprot.trans.flush()
4660 
 
4661 
  def recv_saveEBSSettlementSummary(self, ):
4662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4663 
    if mtype == TMessageType.EXCEPTION:
4664 
      x = TApplicationException()
4665 
      x.read(self._iprot)
4666 
      self._iprot.readMessageEnd()
4667 
      raise x
4668 
    result = saveEBSSettlementSummary_result()
4669 
    result.read(self._iprot)
4670 
    self._iprot.readMessageEnd()
4671 
    if result.ex is not None:
4672 
      raise result.ex
4673 
    return
4674 
 
5386 phani.kuma 4675 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4676 
    """
4677 
    Parameters:
5189 varun.gupt 4678 
     - referenceId
4679 
     - isRefund
4600 varun.gupt 4680 
    """
5386 phani.kuma 4681 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4682 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4683 
 
5386 phani.kuma 4684 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4685 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4686 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4687 
    args.referenceId = referenceId
4688 
    args.isRefund = isRefund
4600 varun.gupt 4689 
    args.write(self._oprot)
4690 
    self._oprot.writeMessageEnd()
4691 
    self._oprot.trans.flush()
4692 
 
5386 phani.kuma 4693 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4695 
    if mtype == TMessageType.EXCEPTION:
4696 
      x = TApplicationException()
4697 
      x.read(self._iprot)
4698 
      self._iprot.readMessageEnd()
4699 
      raise x
5386 phani.kuma 4700 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4701 
    result.read(self._iprot)
4702 
    self._iprot.readMessageEnd()
4703 
    if result.success is not None:
4704 
      return result.success
4705 
    if result.ex is not None:
4706 
      raise result.ex
5386 phani.kuma 4707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4708 
 
5386 phani.kuma 4709 
  def getSettlementForCod(self, orderId, isRefund):
4710 
    """
4711 
    Parameters:
4712 
     - orderId
4713 
     - isRefund
4714 
    """
4715 
    self.send_getSettlementForCod(orderId, isRefund)
4716 
    return self.recv_getSettlementForCod()
4717 
 
4718 
  def send_getSettlementForCod(self, orderId, isRefund):
4719 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4720 
    args = getSettlementForCod_args()
4721 
    args.orderId = orderId
4722 
    args.isRefund = isRefund
4723 
    args.write(self._oprot)
4724 
    self._oprot.writeMessageEnd()
4725 
    self._oprot.trans.flush()
4726 
 
4727 
  def recv_getSettlementForCod(self, ):
4728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4729 
    if mtype == TMessageType.EXCEPTION:
4730 
      x = TApplicationException()
4731 
      x.read(self._iprot)
4732 
      self._iprot.readMessageEnd()
4733 
      raise x
4734 
    result = getSettlementForCod_result()
4735 
    result.read(self._iprot)
4736 
    self._iprot.readMessageEnd()
4737 
    if result.success is not None:
4738 
      return result.success
4739 
    if result.ex is not None:
4740 
      raise result.ex
4741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4742 
 
4600 varun.gupt 4743 
  def getEBSSettlementSummaries(self, ):
4744 
    self.send_getEBSSettlementSummaries()
4745 
    return self.recv_getEBSSettlementSummaries()
4746 
 
4747 
  def send_getEBSSettlementSummaries(self, ):
4748 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4749 
    args = getEBSSettlementSummaries_args()
4750 
    args.write(self._oprot)
4751 
    self._oprot.writeMessageEnd()
4752 
    self._oprot.trans.flush()
4753 
 
4754 
  def recv_getEBSSettlementSummaries(self, ):
4755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4756 
    if mtype == TMessageType.EXCEPTION:
4757 
      x = TApplicationException()
4758 
      x.read(self._iprot)
4759 
      self._iprot.readMessageEnd()
4760 
      raise x
4761 
    result = getEBSSettlementSummaries_result()
4762 
    result.read(self._iprot)
4763 
    self._iprot.readMessageEnd()
4764 
    if result.success is not None:
4765 
      return result.success
4766 
    if result.ex is not None:
4767 
      raise result.ex
4768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4769 
 
4770 
  def markEBSSettlementUploaded(self, settlementId):
4771 
    """
4772 
    Parameters:
4773 
     - settlementId
4774 
    """
4775 
    self.send_markEBSSettlementUploaded(settlementId)
4776 
    self.recv_markEBSSettlementUploaded()
4777 
 
4778 
  def send_markEBSSettlementUploaded(self, settlementId):
4779 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4780 
    args = markEBSSettlementUploaded_args()
4781 
    args.settlementId = settlementId
4782 
    args.write(self._oprot)
4783 
    self._oprot.writeMessageEnd()
4784 
    self._oprot.trans.flush()
4785 
 
4786 
  def recv_markEBSSettlementUploaded(self, ):
4787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4788 
    if mtype == TMessageType.EXCEPTION:
4789 
      x = TApplicationException()
4790 
      x.read(self._iprot)
4791 
      self._iprot.readMessageEnd()
4792 
      raise x
4793 
    result = markEBSSettlementUploaded_result()
4794 
    result.read(self._iprot)
4795 
    self._iprot.readMessageEnd()
4796 
    if result.ex is not None:
4797 
      raise result.ex
4798 
    return
4799 
 
4800 
  def getEBSSettlementDate(self, settlementId):
4801 
    """
4802 
    Parameters:
4803 
     - settlementId
4804 
    """
4805 
    self.send_getEBSSettlementDate(settlementId)
4806 
    return self.recv_getEBSSettlementDate()
4807 
 
4808 
  def send_getEBSSettlementDate(self, settlementId):
4809 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4810 
    args = getEBSSettlementDate_args()
4811 
    args.settlementId = settlementId
4812 
    args.write(self._oprot)
4813 
    self._oprot.writeMessageEnd()
4814 
    self._oprot.trans.flush()
4815 
 
4816 
  def recv_getEBSSettlementDate(self, ):
4817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4818 
    if mtype == TMessageType.EXCEPTION:
4819 
      x = TApplicationException()
4820 
      x.read(self._iprot)
4821 
      self._iprot.readMessageEnd()
4822 
      raise x
4823 
    result = getEBSSettlementDate_result()
4824 
    result.read(self._iprot)
4825 
    self._iprot.readMessageEnd()
4826 
    if result.success is not None:
4827 
      return result.success
4828 
    if result.ex is not None:
4829 
      raise result.ex
4830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4831 
 
4715 varun.gupt 4832 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4833 
    """
4834 
    Parameters:
4835 
     - settlementDateFrom
4836 
     - settlementDateTo
4837 
     - isRefund
4838 
    """
4839 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4840 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4841 
 
4715 varun.gupt 4842 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4843 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4844 
    args = getSettlementsByDate_args()
4845 
    args.settlementDateFrom = settlementDateFrom
4846 
    args.settlementDateTo = settlementDateTo
4847 
    args.isRefund = isRefund
4848 
    args.write(self._oprot)
4849 
    self._oprot.writeMessageEnd()
4850 
    self._oprot.trans.flush()
4851 
 
4852 
  def recv_getSettlementsByDate(self, ):
4853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4854 
    if mtype == TMessageType.EXCEPTION:
4855 
      x = TApplicationException()
4856 
      x.read(self._iprot)
4857 
      self._iprot.readMessageEnd()
4858 
      raise x
4859 
    result = getSettlementsByDate_result()
4860 
    result.read(self._iprot)
4861 
    self._iprot.readMessageEnd()
4862 
    if result.success is not None:
4863 
      return result.success
4864 
    if result.ex is not None:
4865 
      raise result.ex
4866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4867 
 
4868 
  def getReshippedOrderIds(self, orderIds):
4869 
    """
4870 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4871 
 
4872 
    Parameters:
4873 
     - orderIds
4874 
    """
4875 
    self.send_getReshippedOrderIds(orderIds)
4876 
    return self.recv_getReshippedOrderIds()
4877 
 
4878 
  def send_getReshippedOrderIds(self, orderIds):
4879 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4880 
    args = getReshippedOrderIds_args()
4881 
    args.orderIds = orderIds
4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_getReshippedOrderIds(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = getReshippedOrderIds_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.success is not None:
4897 
      return result.success
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4901 
 
4875 varun.gupt 4902 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4903 
    """
4904 
    Parameters:
4905 
     - vendorId
4906 
    """
4907 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4908 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4909 
 
4875 varun.gupt 4910 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4911 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4912 
    args = getOrdersWhereVendorNotPaid_args()
4913 
    args.vendorId = vendorId
4914 
    args.write(self._oprot)
4915 
    self._oprot.writeMessageEnd()
4916 
    self._oprot.trans.flush()
4917 
 
4918 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4920 
    if mtype == TMessageType.EXCEPTION:
4921 
      x = TApplicationException()
4922 
      x.read(self._iprot)
4923 
      self._iprot.readMessageEnd()
4924 
      raise x
4925 
    result = getOrdersWhereVendorNotPaid_result()
4926 
    result.read(self._iprot)
4927 
    self._iprot.readMessageEnd()
4928 
    if result.success is not None:
4929 
      return result.success
4930 
    if result.ex is not None:
4931 
      raise result.ex
4932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4933 
 
5031 varun.gupt 4934 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4935 
    """
4936 
    Parameters:
4937 
     - startDate
4938 
     - endDate
4939 
    """
4940 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4941 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4942 
 
5031 varun.gupt 4943 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4944 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4945 
    args = getStatusDistributionOfOrders_args()
4946 
    args.startDate = startDate
4947 
    args.endDate = endDate
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_getStatusDistributionOfOrders(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = getStatusDistributionOfOrders_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.success is not None:
4963 
      return result.success
4964 
    if result.ex is not None:
4965 
      raise result.ex
4966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4967 
 
5067 varun.gupt 4968 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4969 
    """
4970 
    Parameters:
4971 
     - status
4972 
     - startDatetime
4973 
     - endDatetime
4974 
    """
4975 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4976 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4977 
 
5067 varun.gupt 4978 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4979 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4980 
    args = getOrderIdsForStatus_args()
4981 
    args.status = status
4982 
    args.startDatetime = startDatetime
4983 
    args.endDatetime = endDatetime
4984 
    args.write(self._oprot)
4985 
    self._oprot.writeMessageEnd()
4986 
    self._oprot.trans.flush()
4987 
 
4988 
  def recv_getOrderIdsForStatus(self, ):
4989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4990 
    if mtype == TMessageType.EXCEPTION:
4991 
      x = TApplicationException()
4992 
      x.read(self._iprot)
4993 
      self._iprot.readMessageEnd()
4994 
      raise x
4995 
    result = getOrderIdsForStatus_result()
4996 
    result.read(self._iprot)
4997 
    self._iprot.readMessageEnd()
4998 
    if result.success is not None:
4999 
      return result.success
5000 
    if result.ex is not None:
5001 
      raise result.ex
5002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5003 
 
5348 anupam.sin 5004 
  def updateCODAgent(self, agent, orderId):
5005 
    """
5006 
    Updates the agent who handled the COD verification call
5007 
 
5008 
    Parameters:
5009 
     - agent
5010 
     - orderId
5011 
    """
5012 
    self.send_updateCODAgent(agent, orderId)
5013 
    self.recv_updateCODAgent()
5014 
 
5015 
  def send_updateCODAgent(self, agent, orderId):
5016 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5017 
    args = updateCODAgent_args()
5018 
    args.agent = agent
5019 
    args.orderId = orderId
5020 
    args.write(self._oprot)
5021 
    self._oprot.writeMessageEnd()
5022 
    self._oprot.trans.flush()
5023 
 
5024 
  def recv_updateCODAgent(self, ):
5025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5026 
    if mtype == TMessageType.EXCEPTION:
5027 
      x = TApplicationException()
5028 
      x.read(self._iprot)
5029 
      self._iprot.readMessageEnd()
5030 
      raise x
5031 
    result = updateCODAgent_result()
5032 
    result.read(self._iprot)
5033 
    self._iprot.readMessageEnd()
5034 
    if result.ex is not None:
5035 
      raise result.ex
5036 
    return
5037 
 
5099 varun.gupt 5038 
  def updateOrderAsPaidToVendor(self, orderId):
5039 
    """
5040 
    Parameters:
5041 
     - orderId
5042 
    """
5043 
    self.send_updateOrderAsPaidToVendor(orderId)
5044 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5045 
 
5099 varun.gupt 5046 
  def send_updateOrderAsPaidToVendor(self, orderId):
5047 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5048 
    args = updateOrderAsPaidToVendor_args()
5049 
    args.orderId = orderId
5050 
    args.write(self._oprot)
5051 
    self._oprot.writeMessageEnd()
5052 
    self._oprot.trans.flush()
5053 
 
5054 
  def recv_updateOrderAsPaidToVendor(self, ):
5055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5056 
    if mtype == TMessageType.EXCEPTION:
5057 
      x = TApplicationException()
5058 
      x.read(self._iprot)
5059 
      self._iprot.readMessageEnd()
5060 
      raise x
5061 
    result = updateOrderAsPaidToVendor_result()
5062 
    result.read(self._iprot)
5063 
    self._iprot.readMessageEnd()
5064 
    if result.ex is not None:
5065 
      raise result.ex
5066 
    return
5067 
 
5386 phani.kuma 5068 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5069 
    """
5070 
    Parameters:
5071 
     - orderId
5072 
    """
5073 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5074 
    self.recv_updateOrderOnlyAsPaidToVendor()
5075 
 
5076 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5077 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5078 
    args = updateOrderOnlyAsPaidToVendor_args()
5079 
    args.orderId = orderId
5080 
    args.write(self._oprot)
5081 
    self._oprot.writeMessageEnd()
5082 
    self._oprot.trans.flush()
5083 
 
5084 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5086 
    if mtype == TMessageType.EXCEPTION:
5087 
      x = TApplicationException()
5088 
      x.read(self._iprot)
5089 
      self._iprot.readMessageEnd()
5090 
      raise x
5091 
    result = updateOrderOnlyAsPaidToVendor_result()
5092 
    result.read(self._iprot)
5093 
    self._iprot.readMessageEnd()
5094 
    if result.ex is not None:
5095 
      raise result.ex
5096 
    return
5097 
 
5208 varun.gupt 5098 
  def getRefundedOrdersMarkedPaid(self, ):
5099 
    self.send_getRefundedOrdersMarkedPaid()
5100 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5101 
 
5208 varun.gupt 5102 
  def send_getRefundedOrdersMarkedPaid(self, ):
5103 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5104 
    args = getRefundedOrdersMarkedPaid_args()
5105 
    args.write(self._oprot)
5106 
    self._oprot.writeMessageEnd()
5107 
    self._oprot.trans.flush()
5108 
 
5109 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5111 
    if mtype == TMessageType.EXCEPTION:
5112 
      x = TApplicationException()
5113 
      x.read(self._iprot)
5114 
      self._iprot.readMessageEnd()
5115 
      raise x
5116 
    result = getRefundedOrdersMarkedPaid_result()
5117 
    result.read(self._iprot)
5118 
    self._iprot.readMessageEnd()
5119 
    if result.success is not None:
5120 
      return result.success
5121 
    if result.ex is not None:
5122 
      raise result.ex
5123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5124 
 
5125 
 
3376 rajveer 5126 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5127 
  def __init__(self, handler):
3376 rajveer 5128 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5129 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5130 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5131 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5132 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5133 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5134 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5135 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5136 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5137 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5138 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5139 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5140 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5141 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5142 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5143 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5144 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5145 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5146 
    self._processMap["createOrder"] = Processor.process_createOrder
5147 
    self._processMap["getOrder"] = Processor.process_getOrder
5148 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5149 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5150 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5151 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5152 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5153 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5154 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5155 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5156 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5157 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5158 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5159 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5160 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5161 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5162 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5163 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5164 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5165 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5166 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5167 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5168 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5169 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5170 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5171 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5172 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5173 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5174 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5175 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5176 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5177 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5178 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5179 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5180 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5181 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5182 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5183 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5184 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5185 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5186 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5187 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5188 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5189 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5190 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5191 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5192 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5193 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5194 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5195 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5196 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5197 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5198 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5199 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5200 
    self._processMap["changeItem"] = Processor.process_changeItem
5201 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5202 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5203 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5204 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5205 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5206 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5207 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5208 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5209 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5210 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5211 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5212 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5213 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5214 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5215 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5216 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5217 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5218 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5219 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5220 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5221 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5222 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5223 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5224 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5225 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5226 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5227 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5228 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5229 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5230 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5231 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5232 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5233 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5234 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4875 varun.gupt 5235 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5236 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5237 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5238 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5239 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5240 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5241 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5242 
 
5243 
  def process(self, iprot, oprot):
5244 
    (name, type, seqid) = iprot.readMessageBegin()
5245 
    if name not in self._processMap:
5246 
      iprot.skip(TType.STRUCT)
5247 
      iprot.readMessageEnd()
5248 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5249 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5250 
      x.write(oprot)
5251 
      oprot.writeMessageEnd()
5252 
      oprot.trans.flush()
5253 
      return
5254 
    else:
5255 
      self._processMap[name](self, seqid, iprot, oprot)
5256 
    return True
5257 
 
5258 
  def process_createTransaction(self, seqid, iprot, oprot):
5259 
    args = createTransaction_args()
5260 
    args.read(iprot)
5261 
    iprot.readMessageEnd()
5262 
    result = createTransaction_result()
5263 
    try:
132 ashish 5264 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5265 
    except TransactionServiceException, ex:
5266 
      result.ex = ex
5267 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
5271 
 
5272 
  def process_getTransaction(self, seqid, iprot, oprot):
5273 
    args = getTransaction_args()
5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
5276 
    result = getTransaction_result()
5277 
    try:
5278 
      result.success = self._handler.getTransaction(args.id)
5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
5281 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
5286 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5287 
    args = getTransactionsForCustomer_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = getTransactionsForCustomer_result()
5291 
    try:
5292 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5293 
    except TransactionServiceException, ex:
5294 
      result.ex = ex
5295 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
5299 
 
132 ashish 5300 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5301 
    args = getTransactionsForShoppingCartId_args()
5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
5304 
    result = getTransactionsForShoppingCartId_result()
5305 
    try:
5306 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5307 
    except TransactionServiceException, ex:
5308 
      result.ex = ex
5309 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
5313 
 
94 ashish 5314 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5315 
    args = getTransactionStatus_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = getTransactionStatus_result()
5319 
    try:
5320 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5321 
    except TransactionServiceException, ex:
5322 
      result.ex = ex
5323 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5324 
    result.write(oprot)
5325 
    oprot.writeMessageEnd()
5326 
    oprot.trans.flush()
5327 
 
5328 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5329 
    args = changeTransactionStatus_args()
5330 
    args.read(iprot)
5331 
    iprot.readMessageEnd()
5332 
    result = changeTransactionStatus_result()
5333 
    try:
5387 rajveer 5334 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.selfPickup)
94 ashish 5335 
    except TransactionServiceException, ex:
5336 
      result.ex = ex
5337 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5338 
    result.write(oprot)
5339 
    oprot.writeMessageEnd()
5340 
    oprot.trans.flush()
5341 
 
1398 varun.gupt 5342 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5343 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5344 
    args.read(iprot)
5345 
    iprot.readMessageEnd()
1398 varun.gupt 5346 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5347 
    try:
1398 varun.gupt 5348 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5349 
    except TransactionServiceException, ex:
5350 
      result.ex = ex
1398 varun.gupt 5351 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
5355 
 
483 rajveer 5356 
  def process_getAllOrders(self, seqid, iprot, oprot):
5357 
    args = getAllOrders_args()
94 ashish 5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
483 rajveer 5360 
    result = getAllOrders_result()
94 ashish 5361 
    try:
4801 anupam.sin 5362 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5363 
    except TransactionServiceException, ex:
5364 
      result.ex = ex
483 rajveer 5365 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
5369 
 
4133 chandransh 5370 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5371 
    args = getOrdersInBatch_args()
5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
5374 
    result = getOrdersInBatch_result()
5375 
    try:
5376 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5377 
    except TransactionServiceException, ex:
5378 
      result.ex = ex
5379 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
5384 
  def process_getOrderCount(self, seqid, iprot, oprot):
5385 
    args = getOrderCount_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = getOrderCount_result()
5389 
    try:
5390 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5391 
    except TransactionServiceException, ex:
5392 
      result.ex = ex
5393 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
5397 
 
999 varun.gupt 5398 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5399 
    args = getOrdersByBillingDate_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = getOrdersByBillingDate_result()
5403 
    try:
5404 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5405 
    except TransactionServiceException, ex:
5406 
      result.ex = ex
5407 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
5411 
 
3427 chandransh 5412 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5413 
    args = getOrdersByShippingDate_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = getOrdersByShippingDate_result()
5417 
    try:
3451 chandransh 5418 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5419 
    except TransactionServiceException, ex:
5420 
      result.ex = ex
5421 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
1382 varun.gupt 5426 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5427 
    args = getReturnableOrdersForCustomer_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = getReturnableOrdersForCustomer_result()
5431 
    try:
5432 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5433 
    except TransactionServiceException, ex:
5434 
      result.ex = ex
5435 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
5439 
 
5440 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5441 
    args = getCancellableOrdersForCustomer_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = getCancellableOrdersForCustomer_result()
5445 
    try:
5446 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5447 
    except TransactionServiceException, ex:
5448 
      result.ex = ex
5449 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
5453 
 
483 rajveer 5454 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5455 
    args = changeOrderStatus_args()
94 ashish 5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
483 rajveer 5458 
    result = changeOrderStatus_result()
94 ashish 5459 
    try:
483 rajveer 5460 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5461 
    except TransactionServiceException, ex:
5462 
      result.ex = ex
483 rajveer 5463 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5464 
    result.write(oprot)
5465 
    oprot.writeMessageEnd()
5466 
    oprot.trans.flush()
5467 
 
483 rajveer 5468 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5469 
    args = getOrdersForTransaction_args()
94 ashish 5470 
    args.read(iprot)
5471 
    iprot.readMessageEnd()
483 rajveer 5472 
    result = getOrdersForTransaction_result()
94 ashish 5473 
    try:
1528 ankur.sing 5474 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5475 
    except TransactionServiceException, ex:
5476 
      result.ex = ex
483 rajveer 5477 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
5481 
 
483 rajveer 5482 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5483 
    args = getOrdersForCustomer_args()
94 ashish 5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
483 rajveer 5486 
    result = getOrdersForCustomer_result()
94 ashish 5487 
    try:
3014 chandransh 5488 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5489 
    except TransactionServiceException, ex:
5490 
      result.ex = ex
483 rajveer 5491 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5492 
    result.write(oprot)
5493 
    oprot.writeMessageEnd()
5494 
    oprot.trans.flush()
5495 
 
483 rajveer 5496 
  def process_createOrder(self, seqid, iprot, oprot):
5497 
    args = createOrder_args()
94 ashish 5498 
    args.read(iprot)
5499 
    iprot.readMessageEnd()
483 rajveer 5500 
    result = createOrder_result()
94 ashish 5501 
    try:
483 rajveer 5502 
      result.success = self._handler.createOrder(args.order)
94 ashish 5503 
    except TransactionServiceException, ex:
5504 
      result.ex = ex
483 rajveer 5505 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5506 
    result.write(oprot)
5507 
    oprot.writeMessageEnd()
5508 
    oprot.trans.flush()
5509 
 
483 rajveer 5510 
  def process_getOrder(self, seqid, iprot, oprot):
5511 
    args = getOrder_args()
94 ashish 5512 
    args.read(iprot)
5513 
    iprot.readMessageEnd()
483 rajveer 5514 
    result = getOrder_result()
94 ashish 5515 
    try:
483 rajveer 5516 
      result.success = self._handler.getOrder(args.id)
94 ashish 5517 
    except TransactionServiceException, ex:
5518 
      result.ex = ex
483 rajveer 5519 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5520 
    result.write(oprot)
5521 
    oprot.writeMessageEnd()
5522 
    oprot.trans.flush()
5523 
 
483 rajveer 5524 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5525 
    args = getLineItemsForOrder_args()
94 ashish 5526 
    args.read(iprot)
5527 
    iprot.readMessageEnd()
483 rajveer 5528 
    result = getLineItemsForOrder_result()
94 ashish 5529 
    try:
483 rajveer 5530 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5531 
    except TransactionServiceException, ex:
5532 
      result.ex = ex
483 rajveer 5533 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5534 
    result.write(oprot)
5535 
    oprot.writeMessageEnd()
5536 
    oprot.trans.flush()
5537 
 
4999 phani.kuma 5538 
  def process_getOrderList(self, seqid, iprot, oprot):
5539 
    args = getOrderList_args()
5540 
    args.read(iprot)
5541 
    iprot.readMessageEnd()
5542 
    result = getOrderList_result()
5543 
    result.success = self._handler.getOrderList(args.order_ids)
5544 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5545 
    result.write(oprot)
5546 
    oprot.writeMessageEnd()
5547 
    oprot.trans.flush()
5548 
 
5386 phani.kuma 5549 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5550 
    args = getOrderListForVendor_args()
5551 
    args.read(iprot)
5552 
    iprot.readMessageEnd()
5553 
    result = getOrderListForVendor_result()
5554 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5555 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5556 
    result.write(oprot)
5557 
    oprot.writeMessageEnd()
5558 
    oprot.trans.flush()
5559 
 
1528 ankur.sing 5560 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5561 
    args = getOrderForCustomer_args()
5562 
    args.read(iprot)
5563 
    iprot.readMessageEnd()
5564 
    result = getOrderForCustomer_result()
5565 
    try:
5566 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5567 
    except TransactionServiceException, ex:
5568 
      result.ex = ex
5569 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5570 
    result.write(oprot)
5571 
    oprot.writeMessageEnd()
5572 
    oprot.trans.flush()
5573 
 
3064 chandransh 5574 
  def process_getAlerts(self, seqid, iprot, oprot):
5575 
    args = getAlerts_args()
5576 
    args.read(iprot)
5577 
    iprot.readMessageEnd()
5578 
    result = getAlerts_result()
4444 rajveer 5579 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5580 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
4394 rajveer 5585 
  def process_addAlert(self, seqid, iprot, oprot):
5586 
    args = addAlert_args()
3064 chandransh 5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
4394 rajveer 5589 
    result = addAlert_result()
4444 rajveer 5590 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5591 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
5595 
 
4444 rajveer 5596 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5597 
    args = markAlertsAsSeen_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = markAlertsAsSeen_result()
5601 
    self._handler.markAlertsAsSeen(args.warehouseId)
5602 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
3064 chandransh 5607 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5608 
    args = getValidOrderCount_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = getValidOrderCount_result()
5612 
    result.success = self._handler.getValidOrderCount()
5613 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5614 
    result.write(oprot)
5615 
    oprot.writeMessageEnd()
5616 
    oprot.trans.flush()
5617 
 
5618 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5619 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
5622 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5623 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5624 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5625 
    result.write(oprot)
5626 
    oprot.writeMessageEnd()
5627 
    oprot.trans.flush()
5628 
 
5629 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5630 
    args = getValidOrdersAmountRange_args()
5631 
    args.read(iprot)
5632 
    iprot.readMessageEnd()
5633 
    result = getValidOrdersAmountRange_result()
5634 
    result.success = self._handler.getValidOrdersAmountRange()
5635 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5636 
    result.write(oprot)
5637 
    oprot.writeMessageEnd()
5638 
    oprot.trans.flush()
5639 
 
5640 
  def process_getValidOrders(self, seqid, iprot, oprot):
5641 
    args = getValidOrders_args()
5642 
    args.read(iprot)
5643 
    iprot.readMessageEnd()
5644 
    result = getValidOrders_result()
5645 
    result.success = self._handler.getValidOrders(args.limit)
5646 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5647 
    result.write(oprot)
5648 
    oprot.writeMessageEnd()
5649 
    oprot.trans.flush()
5650 
 
1220 chandransh 5651 
  def process_batchOrders(self, seqid, iprot, oprot):
5652 
    args = batchOrders_args()
5653 
    args.read(iprot)
5654 
    iprot.readMessageEnd()
5655 
    result = batchOrders_result()
5656 
    try:
5657 
      result.success = self._handler.batchOrders(args.warehouseId)
5658 
    except TransactionServiceException, ex:
5659 
      result.ex = ex
5660 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5661 
    result.write(oprot)
5662 
    oprot.writeMessageEnd()
5663 
    oprot.trans.flush()
5664 
 
1208 chandransh 5665 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5666 
    args = markOrderAsOutOfStock_args()
5667 
    args.read(iprot)
5668 
    iprot.readMessageEnd()
5669 
    result = markOrderAsOutOfStock_result()
5670 
    try:
5671 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5672 
    except TransactionServiceException, ex:
5673 
      result.ex = ex
5674 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5675 
    result.write(oprot)
5676 
    oprot.writeMessageEnd()
5677 
    oprot.trans.flush()
5678 
 
3064 chandransh 5679 
  def process_verifyOrder(self, seqid, iprot, oprot):
5680 
    args = verifyOrder_args()
759 chandransh 5681 
    args.read(iprot)
5682 
    iprot.readMessageEnd()
3064 chandransh 5683 
    result = verifyOrder_result()
759 chandransh 5684 
    try:
3064 chandransh 5685 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5686 
    except TransactionServiceException, ex:
5687 
      result.ex = ex
3064 chandransh 5688 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5689 
    result.write(oprot)
5690 
    oprot.writeMessageEnd()
5691 
    oprot.trans.flush()
5692 
 
3064 chandransh 5693 
  def process_acceptOrder(self, seqid, iprot, oprot):
5694 
    args = acceptOrder_args()
1113 chandransh 5695 
    args.read(iprot)
5696 
    iprot.readMessageEnd()
3064 chandransh 5697 
    result = acceptOrder_result()
1113 chandransh 5698 
    try:
3064 chandransh 5699 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5700 
    except TransactionServiceException, ex:
5701 
      result.ex = ex
3064 chandransh 5702 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5703 
    result.write(oprot)
5704 
    oprot.writeMessageEnd()
5705 
    oprot.trans.flush()
5706 
 
3064 chandransh 5707 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5708 
    args = addBillingDetails_args()
1135 chandransh 5709 
    args.read(iprot)
5710 
    iprot.readMessageEnd()
3064 chandransh 5711 
    result = addBillingDetails_result()
1135 chandransh 5712 
    try:
5110 mandeep.dh 5713 
      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 5714 
    except TransactionServiceException, ex:
5715 
      result.ex = ex
3064 chandransh 5716 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5717 
    result.write(oprot)
5718 
    oprot.writeMessageEnd()
5719 
    oprot.trans.flush()
5720 
 
4579 rajveer 5721 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5722 
    args = addInvoiceNumber_args()
5723 
    args.read(iprot)
5724 
    iprot.readMessageEnd()
5725 
    result = addInvoiceNumber_result()
5726 
    try:
4763 rajveer 5727 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5728 
    except TransactionServiceException, ex:
5729 
      result.ex = ex
5730 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5731 
    result.write(oprot)
5732 
    oprot.writeMessageEnd()
5733 
    oprot.trans.flush()
5734 
 
4410 rajveer 5735 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5736 
    args = markOrdersAsShippedFromWarehouse_args()
5737 
    args.read(iprot)
5738 
    iprot.readMessageEnd()
5739 
    result = markOrdersAsShippedFromWarehouse_result()
5740 
    try:
4789 rajveer 5741 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5742 
    except TransactionServiceException, ex:
5743 
      result.ex = ex
5744 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5745 
    result.write(oprot)
5746 
    oprot.writeMessageEnd()
5747 
    oprot.trans.flush()
5748 
 
3064 chandransh 5749 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5750 
    args = markOrdersAsPickedUp_args()
304 ashish 5751 
    args.read(iprot)
5752 
    iprot.readMessageEnd()
3064 chandransh 5753 
    result = markOrdersAsPickedUp_result()
5754 
    try:
4910 phani.kuma 5755 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5756 
    except TransactionServiceException, ex:
5757 
      result.ex = ex
5758 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5759 
    result.write(oprot)
5760 
    oprot.writeMessageEnd()
5761 
    oprot.trans.flush()
94 ashish 5762 
 
4910 phani.kuma 5763 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5764 
    args = getOrdersNotPickedUp_args()
5765 
    args.read(iprot)
5766 
    iprot.readMessageEnd()
5767 
    result = getOrdersNotPickedUp_result()
5768 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5769 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5770 
    result.write(oprot)
5771 
    oprot.writeMessageEnd()
5772 
    oprot.trans.flush()
5773 
 
3064 chandransh 5774 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5775 
    args = markOrdersAsDelivered_args()
304 ashish 5776 
    args.read(iprot)
5777 
    iprot.readMessageEnd()
3064 chandransh 5778 
    result = markOrdersAsDelivered_result()
5779 
    try:
5780 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5781 
    except TransactionServiceException, ex:
5782 
      result.ex = ex
5783 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5784 
    result.write(oprot)
5785 
    oprot.writeMessageEnd()
5786 
    oprot.trans.flush()
5787 
 
4910 phani.kuma 5788 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5789 
    args = markAsRTOrders_args()
1596 ankur.sing 5790 
    args.read(iprot)
5791 
    iprot.readMessageEnd()
4910 phani.kuma 5792 
    result = markAsRTOrders_result()
3064 chandransh 5793 
    try:
4910 phani.kuma 5794 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5795 
    except TransactionServiceException, ex:
5796 
      result.ex = ex
4910 phani.kuma 5797 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5798 
    result.write(oprot)
5799 
    oprot.writeMessageEnd()
5800 
    oprot.trans.flush()
304 ashish 5801 
 
4910 phani.kuma 5802 
  def process_getRTOrders(self, seqid, iprot, oprot):
5803 
    args = getRTOrders_args()
5804 
    args.read(iprot)
5805 
    iprot.readMessageEnd()
5806 
    result = getRTOrders_result()
5807 
    result.success = self._handler.getRTOrders(args.providerId)
5808 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5809 
    result.write(oprot)
5810 
    oprot.writeMessageEnd()
5811 
    oprot.trans.flush()
5812 
 
3064 chandransh 5813 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5814 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5815 
    args.read(iprot)
5816 
    iprot.readMessageEnd()
3064 chandransh 5817 
    result = updateNonDeliveryReason_result()
5818 
    try:
4910 phani.kuma 5819 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5820 
    except TransactionServiceException, ex:
5821 
      result.ex = ex
5822 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5823 
    result.write(oprot)
5824 
    oprot.writeMessageEnd()
5825 
    oprot.trans.flush()
1596 ankur.sing 5826 
 
4910 phani.kuma 5827 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5828 
    args = getNonDeliveredOrdersbyCourier_args()
5829 
    args.read(iprot)
5830 
    iprot.readMessageEnd()
5831 
    result = getNonDeliveredOrdersbyCourier_result()
5832 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5833 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5834 
    result.write(oprot)
5835 
    oprot.writeMessageEnd()
5836 
    oprot.trans.flush()
5837 
 
5838 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5839 
    args = markOrdersAsLocalConnected_args()
5840 
    args.read(iprot)
5841 
    iprot.readMessageEnd()
5842 
    result = markOrdersAsLocalConnected_result()
5843 
    try:
5844 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5845 
    except TransactionServiceException, ex:
5846 
      result.ex = ex
5847 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5848 
    result.write(oprot)
5849 
    oprot.writeMessageEnd()
5850 
    oprot.trans.flush()
5851 
 
5852 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5853 
    args = getOrdersNotLocalConnected_args()
5854 
    args.read(iprot)
5855 
    iprot.readMessageEnd()
5856 
    result = getOrdersNotLocalConnected_result()
5857 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5858 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5859 
    result.write(oprot)
5860 
    oprot.writeMessageEnd()
5861 
    oprot.trans.flush()
5862 
 
5863 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5864 
    args = markOrdersAsDestinationCityReached_args()
5865 
    args.read(iprot)
5866 
    iprot.readMessageEnd()
5867 
    result = markOrdersAsDestinationCityReached_result()
5868 
    try:
5869 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5870 
    except TransactionServiceException, ex:
5871 
      result.ex = ex
5872 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5873 
    result.write(oprot)
5874 
    oprot.writeMessageEnd()
5875 
    oprot.trans.flush()
5876 
 
5877 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5878 
    args = markOrdersAsFirstDeliveryAttempted_args()
5879 
    args.read(iprot)
5880 
    iprot.readMessageEnd()
5881 
    result = markOrdersAsFirstDeliveryAttempted_result()
5882 
    try:
5883 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5884 
    except TransactionServiceException, ex:
5885 
      result.ex = ex
5886 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5887 
    result.write(oprot)
5888 
    oprot.writeMessageEnd()
5889 
    oprot.trans.flush()
5890 
 
3064 chandransh 5891 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5892 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5893 
    args.read(iprot)
5894 
    iprot.readMessageEnd()
3064 chandransh 5895 
    result = getUndeliveredOrders_result()
5896 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5897 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
5901 
 
4783 phani.kuma 5902 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5903 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5907 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5908 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5909 
    result.write(oprot)
5910 
    oprot.writeMessageEnd()
5911 
    oprot.trans.flush()
5912 
 
2536 chandransh 5913 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5914 
    args = toggleDOAFlag_args()
5915 
    args.read(iprot)
5916 
    iprot.readMessageEnd()
5917 
    result = toggleDOAFlag_result()
5918 
    try:
5919 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5920 
    except TransactionServiceException, ex:
5921 
      result.ex = ex
5922 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5923 
    result.write(oprot)
5924 
    oprot.writeMessageEnd()
5925 
    oprot.trans.flush()
1886 ankur.sing 5926 
 
4712 rajveer 5927 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5928 
    args = markOrderAsDelivered_args()
5929 
    args.read(iprot)
5930 
    iprot.readMessageEnd()
5931 
    result = markOrderAsDelivered_result()
5932 
    try:
5933 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5934 
    except TransactionServiceException, ex:
5935 
      result.ex = ex
5936 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5937 
    result.write(oprot)
5938 
    oprot.writeMessageEnd()
5939 
    oprot.trans.flush()
5940 
 
4454 rajveer 5941 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5942 
    args = markOrderDoaRequestReceived_args()
5943 
    args.read(iprot)
5944 
    iprot.readMessageEnd()
5945 
    result = markOrderDoaRequestReceived_result()
5946 
    try:
5947 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5948 
    except TransactionServiceException, ex:
5949 
      result.ex = ex
5950 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5951 
    result.write(oprot)
5952 
    oprot.writeMessageEnd()
5953 
    oprot.trans.flush()
5954 
 
5955 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5956 
    args = markOrderDoaRequestAuthorized_args()
5957 
    args.read(iprot)
5958 
    iprot.readMessageEnd()
5959 
    result = markOrderDoaRequestAuthorized_result()
5960 
    try:
5961 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5962 
    except TransactionServiceException, ex:
5963 
      result.ex = ex
5964 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5965 
    result.write(oprot)
5966 
    oprot.writeMessageEnd()
5967 
    oprot.trans.flush()
5968 
 
4488 rajveer 5969 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5970 
    args = markOrderReturnRequestReceived_args()
5971 
    args.read(iprot)
5972 
    iprot.readMessageEnd()
5973 
    result = markOrderReturnRequestReceived_result()
5974 
    try:
5975 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5976 
    except TransactionServiceException, ex:
5977 
      result.ex = ex
5978 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
5982 
 
5983 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5984 
    args = markOrderReturnRequestAuthorized_args()
5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
5987 
    result = markOrderReturnRequestAuthorized_result()
5988 
    try:
5989 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5990 
    except TransactionServiceException, ex:
5991 
      result.ex = ex
5992 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
5996 
 
2536 chandransh 5997 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5998 
    args = requestPickupNumber_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = requestPickupNumber_result()
6002 
    try:
4579 rajveer 6003 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6004 
    except TransactionServiceException, ex:
6005 
      result.ex = ex
6006 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
6010 
 
6011 
  def process_authorizePickup(self, seqid, iprot, oprot):
6012 
    args = authorizePickup_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = authorizePickup_result()
6016 
    try:
4602 rajveer 6017 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6018 
    except TransactionServiceException, ex:
6019 
      result.ex = ex
6020 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
6024 
 
2764 chandransh 6025 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6026 
    args = markDoasAsPickedUp_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6030 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6031 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6032 
    result.write(oprot)
6033 
    oprot.writeMessageEnd()
6034 
    oprot.trans.flush()
6035 
 
4910 phani.kuma 6036 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6037 
    args = getDoasNotPickedUp_args()
6038 
    args.read(iprot)
6039 
    iprot.readMessageEnd()
6040 
    result = getDoasNotPickedUp_result()
6041 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6042 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6043 
    result.write(oprot)
6044 
    oprot.writeMessageEnd()
6045 
    oprot.trans.flush()
6046 
 
4741 phani.kuma 6047 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6048 
    args = markReturnOrdersAsPickedUp_args()
6049 
    args.read(iprot)
6050 
    iprot.readMessageEnd()
6051 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6052 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6053 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
4910 phani.kuma 6058 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6059 
    args = getReturnOrdersNotPickedUp_args()
6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
6062 
    result = getReturnOrdersNotPickedUp_result()
6063 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6064 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6065 
    result.write(oprot)
6066 
    oprot.writeMessageEnd()
6067 
    oprot.trans.flush()
6068 
 
2616 chandransh 6069 
  def process_receiveReturn(self, seqid, iprot, oprot):
6070 
    args = receiveReturn_args()
2591 chandransh 6071 
    args.read(iprot)
6072 
    iprot.readMessageEnd()
2616 chandransh 6073 
    result = receiveReturn_result()
2591 chandransh 6074 
    try:
4479 rajveer 6075 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6076 
    except TransactionServiceException, ex:
6077 
      result.ex = ex
2616 chandransh 6078 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
2536 chandransh 6082 
 
2591 chandransh 6083 
  def process_validateDoa(self, seqid, iprot, oprot):
6084 
    args = validateDoa_args()
6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
6087 
    result = validateDoa_result()
6088 
    try:
6089 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6090 
    except TransactionServiceException, ex:
6091 
      result.ex = ex
6092 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
6096 
 
4495 rajveer 6097 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6098 
    args = validateReturnProduct_args()
6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
6101 
    result = validateReturnProduct_result()
6102 
    try:
6103 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6104 
    except TransactionServiceException, ex:
6105 
      result.ex = ex
6106 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
2616 chandransh 6111 
  def process_reshipOrder(self, seqid, iprot, oprot):
6112 
    args = reshipOrder_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = reshipOrder_result()
6116 
    try:
6117 
      result.success = self._handler.reshipOrder(args.orderId)
6118 
    except TransactionServiceException, ex:
6119 
      result.ex = ex
6120 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
2591 chandransh 6124 
 
2616 chandransh 6125 
  def process_refundOrder(self, seqid, iprot, oprot):
6126 
    args = refundOrder_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = refundOrder_result()
6130 
    try:
3226 chandransh 6131 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6132 
    except TransactionServiceException, ex:
6133 
      result.ex = ex
6134 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6135 
    result.write(oprot)
6136 
    oprot.writeMessageEnd()
6137 
    oprot.trans.flush()
6138 
 
2690 chandransh 6139 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6140 
    args = getReturnOrders_args()
6141 
    args.read(iprot)
6142 
    iprot.readMessageEnd()
6143 
    result = getReturnOrders_result()
6144 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6145 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6146 
    result.write(oprot)
6147 
    oprot.writeMessageEnd()
6148 
    oprot.trans.flush()
2616 chandransh 6149 
 
2700 chandransh 6150 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6151 
    args = getReturnOrder_args()
6152 
    args.read(iprot)
6153 
    iprot.readMessageEnd()
6154 
    result = getReturnOrder_result()
6155 
    try:
6156 
      result.success = self._handler.getReturnOrder(args.id)
6157 
    except TransactionServiceException, ex:
6158 
      result.ex = ex
6159 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6160 
    result.write(oprot)
6161 
    oprot.writeMessageEnd()
6162 
    oprot.trans.flush()
6163 
 
2690 chandransh 6164 
  def process_processReturn(self, seqid, iprot, oprot):
6165 
    args = processReturn_args()
6166 
    args.read(iprot)
6167 
    iprot.readMessageEnd()
6168 
    result = processReturn_result()
6169 
    try:
6170 
      self._handler.processReturn(args.returnOrderId)
6171 
    except TransactionServiceException, ex:
6172 
      result.ex = ex
6173 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6174 
    result.write(oprot)
6175 
    oprot.writeMessageEnd()
6176 
    oprot.trans.flush()
6177 
 
3451 chandransh 6178 
  def process_updateWeight(self, seqid, iprot, oprot):
6179 
    args = updateWeight_args()
6180 
    args.read(iprot)
6181 
    iprot.readMessageEnd()
6182 
    result = updateWeight_result()
6183 
    try:
6184 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6185 
    except TransactionServiceException, ex:
6186 
      result.ex = ex
6187 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6188 
    result.write(oprot)
6189 
    oprot.writeMessageEnd()
6190 
    oprot.trans.flush()
2819 chandransh 6191 
 
3469 chandransh 6192 
  def process_changeItem(self, seqid, iprot, oprot):
6193 
    args = changeItem_args()
6194 
    args.read(iprot)
6195 
    iprot.readMessageEnd()
6196 
    result = changeItem_result()
6197 
    try:
6198 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6199 
    except TransactionServiceException, ex:
6200 
      result.ex = ex
6201 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6202 
    result.write(oprot)
6203 
    oprot.writeMessageEnd()
6204 
    oprot.trans.flush()
3451 chandransh 6205 
 
3469 chandransh 6206 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6207 
    args = shiftToWarehouse_args()
6208 
    args.read(iprot)
6209 
    iprot.readMessageEnd()
6210 
    result = shiftToWarehouse_result()
6211 
    try:
6212 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6213 
    except TransactionServiceException, ex:
6214 
      result.ex = ex
6215 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6216 
    result.write(oprot)
6217 
    oprot.writeMessageEnd()
6218 
    oprot.trans.flush()
6219 
 
3553 chandransh 6220 
  def process_addDelayReason(self, seqid, iprot, oprot):
6221 
    args = addDelayReason_args()
6222 
    args.read(iprot)
6223 
    iprot.readMessageEnd()
6224 
    result = addDelayReason_result()
6225 
    try:
4647 rajveer 6226 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6227 
    except TransactionServiceException, ex:
6228 
      result.ex = ex
6229 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6230 
    result.write(oprot)
6231 
    oprot.writeMessageEnd()
6232 
    oprot.trans.flush()
3469 chandransh 6233 
 
3956 chandransh 6234 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6235 
    args = reconcileCodCollection_args()
6236 
    args.read(iprot)
6237 
    iprot.readMessageEnd()
6238 
    result = reconcileCodCollection_result()
6239 
    try:
6240 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6241 
    except TransactionServiceException, ex:
6242 
      result.ex = ex
6243 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6244 
    result.write(oprot)
6245 
    oprot.writeMessageEnd()
6246 
    oprot.trans.flush()
3553 chandransh 6247 
 
4008 mandeep.dh 6248 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6249 
    args = getTransactionsRequiringExtraProcessing_args()
6250 
    args.read(iprot)
6251 
    iprot.readMessageEnd()
6252 
    result = getTransactionsRequiringExtraProcessing_result()
6253 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6254 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
3956 chandransh 6258 
 
4008 mandeep.dh 6259 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6260 
    args = markTransactionAsProcessed_args()
6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
6263 
    result = markTransactionAsProcessed_result()
6264 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6265 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6266 
    result.write(oprot)
6267 
    oprot.writeMessageEnd()
6268 
    oprot.trans.flush()
6269 
 
4018 chandransh 6270 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6271 
    args = getItemWiseRiskyOrdersCount_args()
6272 
    args.read(iprot)
6273 
    iprot.readMessageEnd()
6274 
    result = getItemWiseRiskyOrdersCount_result()
6275 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6276 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6277 
    result.write(oprot)
6278 
    oprot.writeMessageEnd()
6279 
    oprot.trans.flush()
4008 mandeep.dh 6280 
 
4295 varun.gupt 6281 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6282 
    args = getOrdersForItemIds_args()
6283 
    args.read(iprot)
6284 
    iprot.readMessageEnd()
6285 
    result = getOrdersForItemIds_result()
6286 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6287 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6288 
    result.write(oprot)
6289 
    oprot.writeMessageEnd()
6290 
    oprot.trans.flush()
6291 
 
4247 rajveer 6292 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6293 
    args = markOrderCancellationRequestReceived_args()
6294 
    args.read(iprot)
6295 
    iprot.readMessageEnd()
6296 
    result = markOrderCancellationRequestReceived_result()
6297 
    try:
6298 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6299 
    except TransactionServiceException, ex:
6300 
      result.ex = ex
6301 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6302 
    result.write(oprot)
6303 
    oprot.writeMessageEnd()
6304 
    oprot.trans.flush()
4018 chandransh 6305 
 
4247 rajveer 6306 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6307 
    args = markOrderCancellationRequestConfirmed_args()
6308 
    args.read(iprot)
6309 
    iprot.readMessageEnd()
6310 
    result = markOrderCancellationRequestConfirmed_result()
6311 
    try:
6312 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6313 
    except TransactionServiceException, ex:
6314 
      result.ex = ex
6315 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6316 
    result.write(oprot)
6317 
    oprot.writeMessageEnd()
6318 
    oprot.trans.flush()
6319 
 
6320 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6321 
    args = markOrderCancellationRequestDenied_args()
6322 
    args.read(iprot)
6323 
    iprot.readMessageEnd()
6324 
    result = markOrderCancellationRequestDenied_result()
6325 
    try:
6326 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6327 
    except TransactionServiceException, ex:
6328 
      result.ex = ex
6329 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6330 
    result.write(oprot)
6331 
    oprot.writeMessageEnd()
6332 
    oprot.trans.flush()
6333 
 
4258 rajveer 6334 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6335 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6336 
    args.read(iprot)
6337 
    iprot.readMessageEnd()
4258 rajveer 6338 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6339 
    try:
4258 rajveer 6340 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6341 
    except TransactionServiceException, ex:
6342 
      result.ex = ex
4258 rajveer 6343 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
4259 anupam.sin 6348 
  def process_refundTransaction(self, seqid, iprot, oprot):
6349 
    args = refundTransaction_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = refundTransaction_result()
6353 
    try:
6354 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6355 
    except TransactionServiceException, ex:
6356 
      result.ex = ex
6357 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6358 
    result.write(oprot)
6359 
    oprot.writeMessageEnd()
6360 
    oprot.trans.flush()
4247 rajveer 6361 
 
4324 mandeep.dh 6362 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6363 
    args = updateShipmentAddress_args()
6364 
    args.read(iprot)
6365 
    iprot.readMessageEnd()
6366 
    result = updateShipmentAddress_result()
6367 
    try:
6368 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6369 
    except TransactionServiceException, ex:
6370 
      result.ex = ex
6371 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6372 
    result.write(oprot)
6373 
    oprot.writeMessageEnd()
6374 
    oprot.trans.flush()
6375 
 
4285 rajveer 6376 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6377 
    args = acceptOrdersForItemId_args()
6378 
    args.read(iprot)
6379 
    iprot.readMessageEnd()
6380 
    result = acceptOrdersForItemId_result()
6381 
    try:
6382 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6383 
    except TransactionServiceException, ex:
6384 
      result.ex = ex
6385 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6386 
    result.write(oprot)
6387 
    oprot.writeMessageEnd()
6388 
    oprot.trans.flush()
4259 anupam.sin 6389 
 
4303 rajveer 6390 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6391 
    args = markOrdersAsPORaised_args()
6392 
    args.read(iprot)
6393 
    iprot.readMessageEnd()
6394 
    result = markOrdersAsPORaised_result()
6395 
    try:
4369 rajveer 6396 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6397 
    except TransactionServiceException, ex:
6398 
      result.ex = ex
6399 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6400 
    result.write(oprot)
6401 
    oprot.writeMessageEnd()
6402 
    oprot.trans.flush()
4285 rajveer 6403 
 
4303 rajveer 6404 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6405 
    args = markOrdersAsReversalInitiated_args()
6406 
    args.read(iprot)
6407 
    iprot.readMessageEnd()
6408 
    result = markOrdersAsReversalInitiated_result()
6409 
    try:
4369 rajveer 6410 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6411 
    except TransactionServiceException, ex:
6412 
      result.ex = ex
6413 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6414 
    result.write(oprot)
6415 
    oprot.writeMessageEnd()
6416 
    oprot.trans.flush()
6417 
 
6418 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6419 
    args = markOrdersAsNotAvailabke_args()
6420 
    args.read(iprot)
6421 
    iprot.readMessageEnd()
6422 
    result = markOrdersAsNotAvailabke_result()
6423 
    try:
4369 rajveer 6424 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6425 
    except TransactionServiceException, ex:
6426 
      result.ex = ex
6427 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6428 
    result.write(oprot)
6429 
    oprot.writeMessageEnd()
6430 
    oprot.trans.flush()
6431 
 
4369 rajveer 6432 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6433 
    args = markOrdersAsTimeout_args()
6434 
    args.read(iprot)
6435 
    iprot.readMessageEnd()
6436 
    result = markOrdersAsTimeout_result()
6437 
    try:
6438 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6439 
    except TransactionServiceException, ex:
6440 
      result.ex = ex
6441 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6442 
    result.write(oprot)
6443 
    oprot.writeMessageEnd()
6444 
    oprot.trans.flush()
4303 rajveer 6445 
 
4662 rajveer 6446 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6447 
    args = markOrderAsLostInTransit_args()
6448 
    args.read(iprot)
6449 
    iprot.readMessageEnd()
6450 
    result = markOrderAsLostInTransit_result()
6451 
    try:
6452 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6453 
    except TransactionServiceException, ex:
6454 
      result.ex = ex
6455 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6456 
    result.write(oprot)
6457 
    oprot.writeMessageEnd()
6458 
    oprot.trans.flush()
6459 
 
4386 anupam.sin 6460 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6461 
    args = getOrderForAwb_args()
6462 
    args.read(iprot)
6463 
    iprot.readMessageEnd()
6464 
    result = getOrderForAwb_result()
6465 
    try:
6466 
      result.success = self._handler.getOrderForAwb(args.awb)
6467 
    except TransactionServiceException, ex:
6468 
      result.ex = ex
6469 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6470 
    result.write(oprot)
6471 
    oprot.writeMessageEnd()
6472 
    oprot.trans.flush()
4369 rajveer 6473 
 
4506 phani.kuma 6474 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6475 
    args = getOrdersForProviderForStatus_args()
6476 
    args.read(iprot)
6477 
    iprot.readMessageEnd()
6478 
    result = getOrdersForProviderForStatus_result()
6479 
    try:
4910 phani.kuma 6480 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6481 
    except TransactionServiceException, ex:
6482 
      result.ex = ex
6483 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6484 
    result.write(oprot)
6485 
    oprot.writeMessageEnd()
6486 
    oprot.trans.flush()
4386 anupam.sin 6487 
 
4600 varun.gupt 6488 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6489 
    args = getBilledOrdersForVendor_args()
6490 
    args.read(iprot)
6491 
    iprot.readMessageEnd()
6492 
    result = getBilledOrdersForVendor_result()
6493 
    try:
6494 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6495 
    except TransactionServiceException, ex:
6496 
      result.ex = ex
6497 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6498 
    result.write(oprot)
6499 
    oprot.writeMessageEnd()
6500 
    oprot.trans.flush()
4506 phani.kuma 6501 
 
4607 rajveer 6502 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6503 
    args = getSlippedSippingDateOrders_args()
6504 
    args.read(iprot)
6505 
    iprot.readMessageEnd()
6506 
    result = getSlippedSippingDateOrders_result()
6507 
    try:
6508 
      result.success = self._handler.getSlippedSippingDateOrders()
6509 
    except TransactionServiceException, ex:
6510 
      result.ex = ex
6511 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6512 
    result.write(oprot)
6513 
    oprot.writeMessageEnd()
6514 
    oprot.trans.flush()
6515 
 
4709 rajveer 6516 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6517 
    args = getCancelledOrders_args()
6518 
    args.read(iprot)
6519 
    iprot.readMessageEnd()
6520 
    result = getCancelledOrders_result()
6521 
    try:
6522 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6523 
    except TransactionServiceException, ex:
6524 
      result.ex = ex
6525 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6526 
    result.write(oprot)
6527 
    oprot.writeMessageEnd()
6528 
    oprot.trans.flush()
6529 
 
4600 varun.gupt 6530 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6531 
    args = saveBluedartSettlements_args()
6532 
    args.read(iprot)
6533 
    iprot.readMessageEnd()
6534 
    result = saveBluedartSettlements_result()
6535 
    try:
6536 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6537 
    except TransactionServiceException, ex:
6538 
      result.ex = ex
6539 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6540 
    result.write(oprot)
6541 
    oprot.writeMessageEnd()
6542 
    oprot.trans.flush()
6543 
 
6544 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6545 
    args = savePaymentSettlements_args()
6546 
    args.read(iprot)
6547 
    iprot.readMessageEnd()
6548 
    result = savePaymentSettlements_result()
6549 
    try:
4905 varun.gupt 6550 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6551 
    except TransactionServiceException, ex:
6552 
      result.ex = ex
6553 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6554 
    result.write(oprot)
6555 
    oprot.writeMessageEnd()
6556 
    oprot.trans.flush()
6557 
 
6558 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6559 
    args = saveEBSSettlementSummary_args()
6560 
    args.read(iprot)
6561 
    iprot.readMessageEnd()
6562 
    result = saveEBSSettlementSummary_result()
6563 
    try:
6564 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6565 
    except TransactionServiceException, ex:
6566 
      result.ex = ex
6567 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6568 
    result.write(oprot)
6569 
    oprot.writeMessageEnd()
6570 
    oprot.trans.flush()
6571 
 
5386 phani.kuma 6572 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6573 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6574 
    args.read(iprot)
6575 
    iprot.readMessageEnd()
5386 phani.kuma 6576 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6577 
    try:
5386 phani.kuma 6578 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6579 
    except TransactionServiceException, ex:
6580 
      result.ex = ex
5386 phani.kuma 6581 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6582 
    result.write(oprot)
6583 
    oprot.writeMessageEnd()
6584 
    oprot.trans.flush()
6585 
 
5386 phani.kuma 6586 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6587 
    args = getSettlementForCod_args()
6588 
    args.read(iprot)
6589 
    iprot.readMessageEnd()
6590 
    result = getSettlementForCod_result()
6591 
    try:
6592 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6593 
    except TransactionServiceException, ex:
6594 
      result.ex = ex
6595 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6596 
    result.write(oprot)
6597 
    oprot.writeMessageEnd()
6598 
    oprot.trans.flush()
6599 
 
4600 varun.gupt 6600 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6601 
    args = getEBSSettlementSummaries_args()
6602 
    args.read(iprot)
6603 
    iprot.readMessageEnd()
6604 
    result = getEBSSettlementSummaries_result()
6605 
    try:
6606 
      result.success = self._handler.getEBSSettlementSummaries()
6607 
    except TransactionServiceException, ex:
6608 
      result.ex = ex
6609 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6610 
    result.write(oprot)
6611 
    oprot.writeMessageEnd()
6612 
    oprot.trans.flush()
6613 
 
6614 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6615 
    args = markEBSSettlementUploaded_args()
6616 
    args.read(iprot)
6617 
    iprot.readMessageEnd()
6618 
    result = markEBSSettlementUploaded_result()
6619 
    try:
6620 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6621 
    except TransactionServiceException, ex:
6622 
      result.ex = ex
6623 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6624 
    result.write(oprot)
6625 
    oprot.writeMessageEnd()
6626 
    oprot.trans.flush()
6627 
 
6628 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6629 
    args = getEBSSettlementDate_args()
6630 
    args.read(iprot)
6631 
    iprot.readMessageEnd()
6632 
    result = getEBSSettlementDate_result()
6633 
    try:
6634 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6635 
    except TransactionServiceException, ex:
6636 
      result.ex = ex
6637 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6641 
 
4715 varun.gupt 6642 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6643 
    args = getSettlementsByDate_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = getSettlementsByDate_result()
6647 
    try:
6648 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6649 
    except TransactionServiceException, ex:
6650 
      result.ex = ex
6651 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6652 
    result.write(oprot)
6653 
    oprot.writeMessageEnd()
6654 
    oprot.trans.flush()
4600 varun.gupt 6655 
 
4715 varun.gupt 6656 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6657 
    args = getReshippedOrderIds_args()
6658 
    args.read(iprot)
6659 
    iprot.readMessageEnd()
6660 
    result = getReshippedOrderIds_result()
6661 
    try:
6662 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6663 
    except TransactionServiceException, ex:
6664 
      result.ex = ex
6665 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6666 
    result.write(oprot)
6667 
    oprot.writeMessageEnd()
6668 
    oprot.trans.flush()
6669 
 
4875 varun.gupt 6670 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6671 
    args = getOrdersWhereVendorNotPaid_args()
6672 
    args.read(iprot)
6673 
    iprot.readMessageEnd()
6674 
    result = getOrdersWhereVendorNotPaid_result()
6675 
    try:
6676 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6677 
    except TransactionServiceException, ex:
6678 
      result.ex = ex
6679 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6680 
    result.write(oprot)
6681 
    oprot.writeMessageEnd()
6682 
    oprot.trans.flush()
4757 mandeep.dh 6683 
 
5031 varun.gupt 6684 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6685 
    args = getStatusDistributionOfOrders_args()
6686 
    args.read(iprot)
6687 
    iprot.readMessageEnd()
6688 
    result = getStatusDistributionOfOrders_result()
6689 
    try:
6690 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6691 
    except TransactionServiceException, ex:
6692 
      result.ex = ex
6693 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6694 
    result.write(oprot)
6695 
    oprot.writeMessageEnd()
6696 
    oprot.trans.flush()
4875 varun.gupt 6697 
 
5067 varun.gupt 6698 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6699 
    args = getOrderIdsForStatus_args()
6700 
    args.read(iprot)
6701 
    iprot.readMessageEnd()
6702 
    result = getOrderIdsForStatus_result()
6703 
    try:
6704 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6705 
    except TransactionServiceException, ex:
6706 
      result.ex = ex
6707 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6708 
    result.write(oprot)
6709 
    oprot.writeMessageEnd()
6710 
    oprot.trans.flush()
5031 varun.gupt 6711 
 
5348 anupam.sin 6712 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6713 
    args = updateCODAgent_args()
6714 
    args.read(iprot)
6715 
    iprot.readMessageEnd()
6716 
    result = updateCODAgent_result()
6717 
    try:
6718 
      self._handler.updateCODAgent(args.agent, args.orderId)
6719 
    except TransactionServiceException, ex:
6720 
      result.ex = ex
6721 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6722 
    result.write(oprot)
6723 
    oprot.writeMessageEnd()
6724 
    oprot.trans.flush()
6725 
 
5099 varun.gupt 6726 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6727 
    args = updateOrderAsPaidToVendor_args()
6728 
    args.read(iprot)
6729 
    iprot.readMessageEnd()
6730 
    result = updateOrderAsPaidToVendor_result()
6731 
    try:
6732 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6733 
    except TransactionServiceException, ex:
6734 
      result.ex = ex
6735 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6736 
    result.write(oprot)
6737 
    oprot.writeMessageEnd()
6738 
    oprot.trans.flush()
5067 varun.gupt 6739 
 
5386 phani.kuma 6740 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
6741 
    args = updateOrderOnlyAsPaidToVendor_args()
6742 
    args.read(iprot)
6743 
    iprot.readMessageEnd()
6744 
    result = updateOrderOnlyAsPaidToVendor_result()
6745 
    try:
6746 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
6747 
    except TransactionServiceException, ex:
6748 
      result.ex = ex
6749 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
6750 
    result.write(oprot)
6751 
    oprot.writeMessageEnd()
6752 
    oprot.trans.flush()
6753 
 
5208 varun.gupt 6754 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6755 
    args = getRefundedOrdersMarkedPaid_args()
6756 
    args.read(iprot)
6757 
    iprot.readMessageEnd()
6758 
    result = getRefundedOrdersMarkedPaid_result()
6759 
    try:
6760 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6761 
    except TransactionServiceException, ex:
6762 
      result.ex = ex
6763 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6764 
    result.write(oprot)
6765 
    oprot.writeMessageEnd()
6766 
    oprot.trans.flush()
5099 varun.gupt 6767 
 
5208 varun.gupt 6768 
 
94 ashish 6769 
# HELPER FUNCTIONS AND STRUCTURES
6770 
 
6771 
class createTransaction_args:
6772 
  """
6773 
  Attributes:
6774 
   - transaction
6775 
  """
6776 
 
6777 
  thrift_spec = (
6778 
    None, # 0
6779 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6780 
  )
6781 
 
6782 
  def __init__(self, transaction=None,):
6783 
    self.transaction = transaction
6784 
 
6785 
  def read(self, iprot):
6786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6788 
      return
6789 
    iprot.readStructBegin()
6790 
    while True:
6791 
      (fname, ftype, fid) = iprot.readFieldBegin()
6792 
      if ftype == TType.STOP:
6793 
        break
6794 
      if fid == 1:
6795 
        if ftype == TType.STRUCT:
6796 
          self.transaction = Transaction()
6797 
          self.transaction.read(iprot)
6798 
        else:
6799 
          iprot.skip(ftype)
6800 
      else:
6801 
        iprot.skip(ftype)
6802 
      iprot.readFieldEnd()
6803 
    iprot.readStructEnd()
6804 
 
6805 
  def write(self, oprot):
6806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6808 
      return
6809 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6810 
    if self.transaction is not None:
94 ashish 6811 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6812 
      self.transaction.write(oprot)
6813 
      oprot.writeFieldEnd()
6814 
    oprot.writeFieldStop()
6815 
    oprot.writeStructEnd()
6816 
 
3431 rajveer 6817 
  def validate(self):
6818 
    return
6819 
 
6820 
 
94 ashish 6821 
  def __repr__(self):
6822 
    L = ['%s=%r' % (key, value)
6823 
      for key, value in self.__dict__.iteritems()]
6824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6825 
 
6826 
  def __eq__(self, other):
6827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6828 
 
6829 
  def __ne__(self, other):
6830 
    return not (self == other)
6831 
 
6832 
class createTransaction_result:
6833 
  """
6834 
  Attributes:
132 ashish 6835 
   - success
94 ashish 6836 
   - ex
6837 
  """
6838 
 
6839 
  thrift_spec = (
132 ashish 6840 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6841 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6842 
  )
6843 
 
132 ashish 6844 
  def __init__(self, success=None, ex=None,):
6845 
    self.success = success
94 ashish 6846 
    self.ex = ex
6847 
 
6848 
  def read(self, iprot):
6849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6851 
      return
6852 
    iprot.readStructBegin()
6853 
    while True:
6854 
      (fname, ftype, fid) = iprot.readFieldBegin()
6855 
      if ftype == TType.STOP:
6856 
        break
132 ashish 6857 
      if fid == 0:
6858 
        if ftype == TType.I64:
6859 
          self.success = iprot.readI64();
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      elif fid == 1:
94 ashish 6863 
        if ftype == TType.STRUCT:
6864 
          self.ex = TransactionServiceException()
6865 
          self.ex.read(iprot)
6866 
        else:
6867 
          iprot.skip(ftype)
6868 
      else:
6869 
        iprot.skip(ftype)
6870 
      iprot.readFieldEnd()
6871 
    iprot.readStructEnd()
6872 
 
6873 
  def write(self, oprot):
6874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6876 
      return
6877 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6878 
    if self.success is not None:
132 ashish 6879 
      oprot.writeFieldBegin('success', TType.I64, 0)
6880 
      oprot.writeI64(self.success)
6881 
      oprot.writeFieldEnd()
3431 rajveer 6882 
    if self.ex is not None:
94 ashish 6883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6884 
      self.ex.write(oprot)
6885 
      oprot.writeFieldEnd()
6886 
    oprot.writeFieldStop()
6887 
    oprot.writeStructEnd()
6888 
 
3431 rajveer 6889 
  def validate(self):
6890 
    return
6891 
 
6892 
 
94 ashish 6893 
  def __repr__(self):
6894 
    L = ['%s=%r' % (key, value)
6895 
      for key, value in self.__dict__.iteritems()]
6896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6897 
 
6898 
  def __eq__(self, other):
6899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6900 
 
6901 
  def __ne__(self, other):
6902 
    return not (self == other)
6903 
 
6904 
class getTransaction_args:
6905 
  """
6906 
  Attributes:
6907 
   - id
6908 
  """
6909 
 
6910 
  thrift_spec = (
6911 
    None, # 0
6912 
    (1, TType.I64, 'id', None, None, ), # 1
6913 
  )
6914 
 
6915 
  def __init__(self, id=None,):
6916 
    self.id = id
6917 
 
6918 
  def read(self, iprot):
6919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6921 
      return
6922 
    iprot.readStructBegin()
6923 
    while True:
6924 
      (fname, ftype, fid) = iprot.readFieldBegin()
6925 
      if ftype == TType.STOP:
6926 
        break
6927 
      if fid == 1:
6928 
        if ftype == TType.I64:
6929 
          self.id = iprot.readI64();
6930 
        else:
6931 
          iprot.skip(ftype)
6932 
      else:
6933 
        iprot.skip(ftype)
6934 
      iprot.readFieldEnd()
6935 
    iprot.readStructEnd()
6936 
 
6937 
  def write(self, oprot):
6938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6940 
      return
6941 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6942 
    if self.id is not None:
94 ashish 6943 
      oprot.writeFieldBegin('id', TType.I64, 1)
6944 
      oprot.writeI64(self.id)
6945 
      oprot.writeFieldEnd()
6946 
    oprot.writeFieldStop()
6947 
    oprot.writeStructEnd()
6948 
 
3431 rajveer 6949 
  def validate(self):
6950 
    return
6951 
 
6952 
 
94 ashish 6953 
  def __repr__(self):
6954 
    L = ['%s=%r' % (key, value)
6955 
      for key, value in self.__dict__.iteritems()]
6956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6957 
 
6958 
  def __eq__(self, other):
6959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6960 
 
6961 
  def __ne__(self, other):
6962 
    return not (self == other)
6963 
 
6964 
class getTransaction_result:
6965 
  """
6966 
  Attributes:
6967 
   - success
6968 
   - ex
6969 
  """
6970 
 
6971 
  thrift_spec = (
6972 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6974 
  )
6975 
 
6976 
  def __init__(self, success=None, ex=None,):
6977 
    self.success = success
6978 
    self.ex = ex
6979 
 
6980 
  def read(self, iprot):
6981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6983 
      return
6984 
    iprot.readStructBegin()
6985 
    while True:
6986 
      (fname, ftype, fid) = iprot.readFieldBegin()
6987 
      if ftype == TType.STOP:
6988 
        break
6989 
      if fid == 0:
6990 
        if ftype == TType.STRUCT:
6991 
          self.success = Transaction()
6992 
          self.success.read(iprot)
6993 
        else:
6994 
          iprot.skip(ftype)
6995 
      elif fid == 1:
6996 
        if ftype == TType.STRUCT:
6997 
          self.ex = TransactionServiceException()
6998 
          self.ex.read(iprot)
6999 
        else:
7000 
          iprot.skip(ftype)
7001 
      else:
7002 
        iprot.skip(ftype)
7003 
      iprot.readFieldEnd()
7004 
    iprot.readStructEnd()
7005 
 
7006 
  def write(self, oprot):
7007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7009 
      return
7010 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7011 
    if self.success is not None:
94 ashish 7012 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7013 
      self.success.write(oprot)
7014 
      oprot.writeFieldEnd()
3431 rajveer 7015 
    if self.ex is not None:
94 ashish 7016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7017 
      self.ex.write(oprot)
7018 
      oprot.writeFieldEnd()
7019 
    oprot.writeFieldStop()
7020 
    oprot.writeStructEnd()
7021 
 
3431 rajveer 7022 
  def validate(self):
7023 
    return
7024 
 
7025 
 
94 ashish 7026 
  def __repr__(self):
7027 
    L = ['%s=%r' % (key, value)
7028 
      for key, value in self.__dict__.iteritems()]
7029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7030 
 
7031 
  def __eq__(self, other):
7032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7033 
 
7034 
  def __ne__(self, other):
7035 
    return not (self == other)
7036 
 
7037 
class getTransactionsForCustomer_args:
7038 
  """
7039 
  Attributes:
7040 
   - customerId
7041 
   - from_date
7042 
   - to_date
7043 
   - status
7044 
  """
7045 
 
7046 
  thrift_spec = (
7047 
    None, # 0
7048 
    (1, TType.I64, 'customerId', None, None, ), # 1
7049 
    (2, TType.I64, 'from_date', None, None, ), # 2
7050 
    (3, TType.I64, 'to_date', None, None, ), # 3
7051 
    (4, TType.I32, 'status', None, None, ), # 4
7052 
  )
7053 
 
7054 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7055 
    self.customerId = customerId
7056 
    self.from_date = from_date
7057 
    self.to_date = to_date
7058 
    self.status = status
7059 
 
7060 
  def read(self, iprot):
7061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7063 
      return
7064 
    iprot.readStructBegin()
7065 
    while True:
7066 
      (fname, ftype, fid) = iprot.readFieldBegin()
7067 
      if ftype == TType.STOP:
7068 
        break
7069 
      if fid == 1:
7070 
        if ftype == TType.I64:
7071 
          self.customerId = iprot.readI64();
7072 
        else:
7073 
          iprot.skip(ftype)
7074 
      elif fid == 2:
7075 
        if ftype == TType.I64:
7076 
          self.from_date = iprot.readI64();
7077 
        else:
7078 
          iprot.skip(ftype)
7079 
      elif fid == 3:
7080 
        if ftype == TType.I64:
7081 
          self.to_date = iprot.readI64();
7082 
        else:
7083 
          iprot.skip(ftype)
7084 
      elif fid == 4:
7085 
        if ftype == TType.I32:
7086 
          self.status = iprot.readI32();
7087 
        else:
7088 
          iprot.skip(ftype)
7089 
      else:
7090 
        iprot.skip(ftype)
7091 
      iprot.readFieldEnd()
7092 
    iprot.readStructEnd()
7093 
 
7094 
  def write(self, oprot):
7095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7097 
      return
7098 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7099 
    if self.customerId is not None:
94 ashish 7100 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7101 
      oprot.writeI64(self.customerId)
7102 
      oprot.writeFieldEnd()
3431 rajveer 7103 
    if self.from_date is not None:
94 ashish 7104 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7105 
      oprot.writeI64(self.from_date)
7106 
      oprot.writeFieldEnd()
3431 rajveer 7107 
    if self.to_date is not None:
94 ashish 7108 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7109 
      oprot.writeI64(self.to_date)
7110 
      oprot.writeFieldEnd()
3431 rajveer 7111 
    if self.status is not None:
94 ashish 7112 
      oprot.writeFieldBegin('status', TType.I32, 4)
7113 
      oprot.writeI32(self.status)
7114 
      oprot.writeFieldEnd()
7115 
    oprot.writeFieldStop()
7116 
    oprot.writeStructEnd()
7117 
 
3431 rajveer 7118 
  def validate(self):
7119 
    return
7120 
 
7121 
 
94 ashish 7122 
  def __repr__(self):
7123 
    L = ['%s=%r' % (key, value)
7124 
      for key, value in self.__dict__.iteritems()]
7125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7126 
 
7127 
  def __eq__(self, other):
7128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7129 
 
7130 
  def __ne__(self, other):
7131 
    return not (self == other)
7132 
 
7133 
class getTransactionsForCustomer_result:
7134 
  """
7135 
  Attributes:
7136 
   - success
7137 
   - ex
7138 
  """
7139 
 
7140 
  thrift_spec = (
7141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7143 
  )
7144 
 
7145 
  def __init__(self, success=None, ex=None,):
7146 
    self.success = success
7147 
    self.ex = ex
7148 
 
7149 
  def read(self, iprot):
7150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7152 
      return
7153 
    iprot.readStructBegin()
7154 
    while True:
7155 
      (fname, ftype, fid) = iprot.readFieldBegin()
7156 
      if ftype == TType.STOP:
7157 
        break
7158 
      if fid == 0:
7159 
        if ftype == TType.LIST:
7160 
          self.success = []
5031 varun.gupt 7161 
          (_etype66, _size63) = iprot.readListBegin()
7162 
          for _i67 in xrange(_size63):
7163 
            _elem68 = Transaction()
7164 
            _elem68.read(iprot)
7165 
            self.success.append(_elem68)
94 ashish 7166 
          iprot.readListEnd()
7167 
        else:
7168 
          iprot.skip(ftype)
7169 
      elif fid == 1:
7170 
        if ftype == TType.STRUCT:
7171 
          self.ex = TransactionServiceException()
7172 
          self.ex.read(iprot)
7173 
        else:
7174 
          iprot.skip(ftype)
7175 
      else:
7176 
        iprot.skip(ftype)
7177 
      iprot.readFieldEnd()
7178 
    iprot.readStructEnd()
7179 
 
7180 
  def write(self, oprot):
7181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7183 
      return
7184 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7185 
    if self.success is not None:
94 ashish 7186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7188 
      for iter69 in self.success:
7189 
        iter69.write(oprot)
94 ashish 7190 
      oprot.writeListEnd()
7191 
      oprot.writeFieldEnd()
3431 rajveer 7192 
    if self.ex is not None:
94 ashish 7193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7194 
      self.ex.write(oprot)
7195 
      oprot.writeFieldEnd()
7196 
    oprot.writeFieldStop()
7197 
    oprot.writeStructEnd()
7198 
 
3431 rajveer 7199 
  def validate(self):
7200 
    return
7201 
 
7202 
 
94 ashish 7203 
  def __repr__(self):
7204 
    L = ['%s=%r' % (key, value)
7205 
      for key, value in self.__dict__.iteritems()]
7206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7207 
 
7208 
  def __eq__(self, other):
7209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7210 
 
7211 
  def __ne__(self, other):
7212 
    return not (self == other)
7213 
 
132 ashish 7214 
class getTransactionsForShoppingCartId_args:
7215 
  """
7216 
  Attributes:
7217 
   - shoppingCartId
7218 
  """
7219 
 
7220 
  thrift_spec = (
7221 
    None, # 0
7222 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7223 
  )
7224 
 
7225 
  def __init__(self, shoppingCartId=None,):
7226 
    self.shoppingCartId = shoppingCartId
7227 
 
7228 
  def read(self, iprot):
7229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7231 
      return
7232 
    iprot.readStructBegin()
7233 
    while True:
7234 
      (fname, ftype, fid) = iprot.readFieldBegin()
7235 
      if ftype == TType.STOP:
7236 
        break
7237 
      if fid == 1:
7238 
        if ftype == TType.I64:
7239 
          self.shoppingCartId = iprot.readI64();
7240 
        else:
7241 
          iprot.skip(ftype)
7242 
      else:
7243 
        iprot.skip(ftype)
7244 
      iprot.readFieldEnd()
7245 
    iprot.readStructEnd()
7246 
 
7247 
  def write(self, oprot):
7248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7250 
      return
7251 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7252 
    if self.shoppingCartId is not None:
132 ashish 7253 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7254 
      oprot.writeI64(self.shoppingCartId)
7255 
      oprot.writeFieldEnd()
7256 
    oprot.writeFieldStop()
7257 
    oprot.writeStructEnd()
7258 
 
3431 rajveer 7259 
  def validate(self):
7260 
    return
7261 
 
7262 
 
132 ashish 7263 
  def __repr__(self):
7264 
    L = ['%s=%r' % (key, value)
7265 
      for key, value in self.__dict__.iteritems()]
7266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7267 
 
7268 
  def __eq__(self, other):
7269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7270 
 
7271 
  def __ne__(self, other):
7272 
    return not (self == other)
7273 
 
7274 
class getTransactionsForShoppingCartId_result:
7275 
  """
7276 
  Attributes:
7277 
   - success
7278 
   - ex
7279 
  """
7280 
 
7281 
  thrift_spec = (
7282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7284 
  )
7285 
 
7286 
  def __init__(self, success=None, ex=None,):
7287 
    self.success = success
7288 
    self.ex = ex
7289 
 
7290 
  def read(self, iprot):
7291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7293 
      return
7294 
    iprot.readStructBegin()
7295 
    while True:
7296 
      (fname, ftype, fid) = iprot.readFieldBegin()
7297 
      if ftype == TType.STOP:
7298 
        break
7299 
      if fid == 0:
7300 
        if ftype == TType.LIST:
7301 
          self.success = []
5031 varun.gupt 7302 
          (_etype73, _size70) = iprot.readListBegin()
7303 
          for _i74 in xrange(_size70):
7304 
            _elem75 = Transaction()
7305 
            _elem75.read(iprot)
7306 
            self.success.append(_elem75)
132 ashish 7307 
          iprot.readListEnd()
7308 
        else:
7309 
          iprot.skip(ftype)
7310 
      elif fid == 1:
7311 
        if ftype == TType.STRUCT:
7312 
          self.ex = TransactionServiceException()
7313 
          self.ex.read(iprot)
7314 
        else:
7315 
          iprot.skip(ftype)
7316 
      else:
7317 
        iprot.skip(ftype)
7318 
      iprot.readFieldEnd()
7319 
    iprot.readStructEnd()
7320 
 
7321 
  def write(self, oprot):
7322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7324 
      return
7325 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7326 
    if self.success is not None:
132 ashish 7327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7328 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7329 
      for iter76 in self.success:
7330 
        iter76.write(oprot)
132 ashish 7331 
      oprot.writeListEnd()
7332 
      oprot.writeFieldEnd()
3431 rajveer 7333 
    if self.ex is not None:
132 ashish 7334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7335 
      self.ex.write(oprot)
7336 
      oprot.writeFieldEnd()
7337 
    oprot.writeFieldStop()
7338 
    oprot.writeStructEnd()
7339 
 
3431 rajveer 7340 
  def validate(self):
7341 
    return
7342 
 
7343 
 
132 ashish 7344 
  def __repr__(self):
7345 
    L = ['%s=%r' % (key, value)
7346 
      for key, value in self.__dict__.iteritems()]
7347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7348 
 
7349 
  def __eq__(self, other):
7350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7351 
 
7352 
  def __ne__(self, other):
7353 
    return not (self == other)
7354 
 
94 ashish 7355 
class getTransactionStatus_args:
7356 
  """
7357 
  Attributes:
7358 
   - transactionId
7359 
  """
7360 
 
7361 
  thrift_spec = (
7362 
    None, # 0
7363 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7364 
  )
7365 
 
7366 
  def __init__(self, transactionId=None,):
7367 
    self.transactionId = transactionId
7368 
 
7369 
  def read(self, iprot):
7370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7372 
      return
7373 
    iprot.readStructBegin()
7374 
    while True:
7375 
      (fname, ftype, fid) = iprot.readFieldBegin()
7376 
      if ftype == TType.STOP:
7377 
        break
7378 
      if fid == 1:
7379 
        if ftype == TType.I64:
7380 
          self.transactionId = iprot.readI64();
7381 
        else:
7382 
          iprot.skip(ftype)
7383 
      else:
7384 
        iprot.skip(ftype)
7385 
      iprot.readFieldEnd()
7386 
    iprot.readStructEnd()
7387 
 
7388 
  def write(self, oprot):
7389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7391 
      return
7392 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7393 
    if self.transactionId is not None:
94 ashish 7394 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7395 
      oprot.writeI64(self.transactionId)
7396 
      oprot.writeFieldEnd()
7397 
    oprot.writeFieldStop()
7398 
    oprot.writeStructEnd()
7399 
 
3431 rajveer 7400 
  def validate(self):
7401 
    return
7402 
 
7403 
 
94 ashish 7404 
  def __repr__(self):
7405 
    L = ['%s=%r' % (key, value)
7406 
      for key, value in self.__dict__.iteritems()]
7407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7408 
 
7409 
  def __eq__(self, other):
7410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7411 
 
7412 
  def __ne__(self, other):
7413 
    return not (self == other)
7414 
 
7415 
class getTransactionStatus_result:
7416 
  """
7417 
  Attributes:
7418 
   - success
7419 
   - ex
7420 
  """
7421 
 
7422 
  thrift_spec = (
7423 
    (0, TType.I32, 'success', None, None, ), # 0
7424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7425 
  )
7426 
 
7427 
  def __init__(self, success=None, ex=None,):
7428 
    self.success = success
7429 
    self.ex = ex
7430 
 
7431 
  def read(self, iprot):
7432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7434 
      return
7435 
    iprot.readStructBegin()
7436 
    while True:
7437 
      (fname, ftype, fid) = iprot.readFieldBegin()
7438 
      if ftype == TType.STOP:
7439 
        break
7440 
      if fid == 0:
7441 
        if ftype == TType.I32:
7442 
          self.success = iprot.readI32();
7443 
        else:
7444 
          iprot.skip(ftype)
7445 
      elif fid == 1:
7446 
        if ftype == TType.STRUCT:
7447 
          self.ex = TransactionServiceException()
7448 
          self.ex.read(iprot)
7449 
        else:
7450 
          iprot.skip(ftype)
7451 
      else:
7452 
        iprot.skip(ftype)
7453 
      iprot.readFieldEnd()
7454 
    iprot.readStructEnd()
7455 
 
7456 
  def write(self, oprot):
7457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7459 
      return
7460 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7461 
    if self.success is not None:
94 ashish 7462 
      oprot.writeFieldBegin('success', TType.I32, 0)
7463 
      oprot.writeI32(self.success)
7464 
      oprot.writeFieldEnd()
3431 rajveer 7465 
    if self.ex is not None:
94 ashish 7466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7467 
      self.ex.write(oprot)
7468 
      oprot.writeFieldEnd()
7469 
    oprot.writeFieldStop()
7470 
    oprot.writeStructEnd()
7471 
 
3431 rajveer 7472 
  def validate(self):
7473 
    return
7474 
 
7475 
 
94 ashish 7476 
  def __repr__(self):
7477 
    L = ['%s=%r' % (key, value)
7478 
      for key, value in self.__dict__.iteritems()]
7479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7480 
 
7481 
  def __eq__(self, other):
7482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7483 
 
7484 
  def __ne__(self, other):
7485 
    return not (self == other)
7486 
 
7487 
class changeTransactionStatus_args:
7488 
  """
7489 
  Attributes:
7490 
   - transactionId
7491 
   - status
7492 
   - description
5387 rajveer 7493 
   - selfPickup
94 ashish 7494 
  """
7495 
 
7496 
  thrift_spec = (
7497 
    None, # 0
7498 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7499 
    (2, TType.I32, 'status', None, None, ), # 2
7500 
    (3, TType.STRING, 'description', None, None, ), # 3
5387 rajveer 7501 
    (4, TType.BOOL, 'selfPickup', None, None, ), # 4
94 ashish 7502 
  )
7503 
 
5387 rajveer 7504 
  def __init__(self, transactionId=None, status=None, description=None, selfPickup=None,):
94 ashish 7505 
    self.transactionId = transactionId
7506 
    self.status = status
7507 
    self.description = description
5387 rajveer 7508 
    self.selfPickup = selfPickup
94 ashish 7509 
 
7510 
  def read(self, iprot):
7511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7513 
      return
7514 
    iprot.readStructBegin()
7515 
    while True:
7516 
      (fname, ftype, fid) = iprot.readFieldBegin()
7517 
      if ftype == TType.STOP:
7518 
        break
7519 
      if fid == 1:
7520 
        if ftype == TType.I64:
7521 
          self.transactionId = iprot.readI64();
7522 
        else:
7523 
          iprot.skip(ftype)
7524 
      elif fid == 2:
7525 
        if ftype == TType.I32:
7526 
          self.status = iprot.readI32();
7527 
        else:
7528 
          iprot.skip(ftype)
7529 
      elif fid == 3:
7530 
        if ftype == TType.STRING:
7531 
          self.description = iprot.readString();
7532 
        else:
7533 
          iprot.skip(ftype)
5387 rajveer 7534 
      elif fid == 4:
7535 
        if ftype == TType.BOOL:
7536 
          self.selfPickup = iprot.readBool();
7537 
        else:
7538 
          iprot.skip(ftype)
94 ashish 7539 
      else:
7540 
        iprot.skip(ftype)
7541 
      iprot.readFieldEnd()
7542 
    iprot.readStructEnd()
7543 
 
7544 
  def write(self, oprot):
7545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7547 
      return
7548 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7549 
    if self.transactionId is not None:
94 ashish 7550 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7551 
      oprot.writeI64(self.transactionId)
7552 
      oprot.writeFieldEnd()
3431 rajveer 7553 
    if self.status is not None:
94 ashish 7554 
      oprot.writeFieldBegin('status', TType.I32, 2)
7555 
      oprot.writeI32(self.status)
7556 
      oprot.writeFieldEnd()
3431 rajveer 7557 
    if self.description is not None:
94 ashish 7558 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7559 
      oprot.writeString(self.description)
7560 
      oprot.writeFieldEnd()
5387 rajveer 7561 
    if self.selfPickup is not None:
7562 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 4)
7563 
      oprot.writeBool(self.selfPickup)
7564 
      oprot.writeFieldEnd()
94 ashish 7565 
    oprot.writeFieldStop()
7566 
    oprot.writeStructEnd()
7567 
 
3431 rajveer 7568 
  def validate(self):
7569 
    return
7570 
 
7571 
 
94 ashish 7572 
  def __repr__(self):
7573 
    L = ['%s=%r' % (key, value)
7574 
      for key, value in self.__dict__.iteritems()]
7575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7576 
 
7577 
  def __eq__(self, other):
7578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7579 
 
7580 
  def __ne__(self, other):
7581 
    return not (self == other)
7582 
 
7583 
class changeTransactionStatus_result:
7584 
  """
7585 
  Attributes:
7586 
   - success
7587 
   - ex
7588 
  """
7589 
 
7590 
  thrift_spec = (
7591 
    (0, TType.BOOL, 'success', None, None, ), # 0
7592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7593 
  )
7594 
 
7595 
  def __init__(self, success=None, ex=None,):
7596 
    self.success = success
7597 
    self.ex = ex
7598 
 
7599 
  def read(self, iprot):
7600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7602 
      return
7603 
    iprot.readStructBegin()
7604 
    while True:
7605 
      (fname, ftype, fid) = iprot.readFieldBegin()
7606 
      if ftype == TType.STOP:
7607 
        break
7608 
      if fid == 0:
7609 
        if ftype == TType.BOOL:
7610 
          self.success = iprot.readBool();
7611 
        else:
7612 
          iprot.skip(ftype)
7613 
      elif fid == 1:
7614 
        if ftype == TType.STRUCT:
7615 
          self.ex = TransactionServiceException()
7616 
          self.ex.read(iprot)
7617 
        else:
7618 
          iprot.skip(ftype)
7619 
      else:
7620 
        iprot.skip(ftype)
7621 
      iprot.readFieldEnd()
7622 
    iprot.readStructEnd()
7623 
 
7624 
  def write(self, oprot):
7625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7627 
      return
7628 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7629 
    if self.success is not None:
94 ashish 7630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7631 
      oprot.writeBool(self.success)
7632 
      oprot.writeFieldEnd()
3431 rajveer 7633 
    if self.ex is not None:
94 ashish 7634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7635 
      self.ex.write(oprot)
7636 
      oprot.writeFieldEnd()
7637 
    oprot.writeFieldStop()
7638 
    oprot.writeStructEnd()
7639 
 
3431 rajveer 7640 
  def validate(self):
7641 
    return
7642 
 
7643 
 
94 ashish 7644 
  def __repr__(self):
7645 
    L = ['%s=%r' % (key, value)
7646 
      for key, value in self.__dict__.iteritems()]
7647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7648 
 
7649 
  def __eq__(self, other):
7650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7651 
 
7652 
  def __ne__(self, other):
7653 
    return not (self == other)
7654 
 
1398 varun.gupt 7655 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7656 
  """
7657 
  Attributes:
7658 
   - transactionId
7659 
  """
7660 
 
7661 
  thrift_spec = (
7662 
    None, # 0
7663 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7664 
  )
7665 
 
7666 
  def __init__(self, transactionId=None,):
7667 
    self.transactionId = transactionId
7668 
 
7669 
  def read(self, iprot):
7670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7672 
      return
7673 
    iprot.readStructBegin()
7674 
    while True:
7675 
      (fname, ftype, fid) = iprot.readFieldBegin()
7676 
      if ftype == TType.STOP:
7677 
        break
7678 
      if fid == 1:
7679 
        if ftype == TType.I64:
7680 
          self.transactionId = iprot.readI64();
7681 
        else:
7682 
          iprot.skip(ftype)
7683 
      else:
7684 
        iprot.skip(ftype)
7685 
      iprot.readFieldEnd()
7686 
    iprot.readStructEnd()
7687 
 
7688 
  def write(self, oprot):
7689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7691 
      return
1398 varun.gupt 7692 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7693 
    if self.transactionId is not None:
1382 varun.gupt 7694 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7695 
      oprot.writeI64(self.transactionId)
7696 
      oprot.writeFieldEnd()
7697 
    oprot.writeFieldStop()
7698 
    oprot.writeStructEnd()
7699 
 
3431 rajveer 7700 
  def validate(self):
7701 
    return
7702 
 
7703 
 
1382 varun.gupt 7704 
  def __repr__(self):
7705 
    L = ['%s=%r' % (key, value)
7706 
      for key, value in self.__dict__.iteritems()]
7707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7708 
 
7709 
  def __eq__(self, other):
7710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7711 
 
7712 
  def __ne__(self, other):
7713 
    return not (self == other)
7714 
 
1398 varun.gupt 7715 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7716 
  """
7717 
  Attributes:
7718 
   - success
7719 
   - ex
7720 
  """
7721 
 
7722 
  thrift_spec = (
7723 
    (0, TType.BOOL, 'success', None, None, ), # 0
7724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7725 
  )
7726 
 
7727 
  def __init__(self, success=None, ex=None,):
7728 
    self.success = success
7729 
    self.ex = ex
7730 
 
7731 
  def read(self, iprot):
7732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7734 
      return
7735 
    iprot.readStructBegin()
7736 
    while True:
7737 
      (fname, ftype, fid) = iprot.readFieldBegin()
7738 
      if ftype == TType.STOP:
7739 
        break
7740 
      if fid == 0:
7741 
        if ftype == TType.BOOL:
7742 
          self.success = iprot.readBool();
7743 
        else:
7744 
          iprot.skip(ftype)
7745 
      elif fid == 1:
7746 
        if ftype == TType.STRUCT:
7747 
          self.ex = TransactionServiceException()
7748 
          self.ex.read(iprot)
7749 
        else:
7750 
          iprot.skip(ftype)
7751 
      else:
7752 
        iprot.skip(ftype)
7753 
      iprot.readFieldEnd()
7754 
    iprot.readStructEnd()
7755 
 
7756 
  def write(self, oprot):
7757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7759 
      return
1398 varun.gupt 7760 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7761 
    if self.success is not None:
1382 varun.gupt 7762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7763 
      oprot.writeBool(self.success)
7764 
      oprot.writeFieldEnd()
3431 rajveer 7765 
    if self.ex is not None:
1382 varun.gupt 7766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7767 
      self.ex.write(oprot)
7768 
      oprot.writeFieldEnd()
7769 
    oprot.writeFieldStop()
7770 
    oprot.writeStructEnd()
7771 
 
3431 rajveer 7772 
  def validate(self):
7773 
    return
7774 
 
7775 
 
1382 varun.gupt 7776 
  def __repr__(self):
7777 
    L = ['%s=%r' % (key, value)
7778 
      for key, value in self.__dict__.iteritems()]
7779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7780 
 
7781 
  def __eq__(self, other):
7782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7783 
 
7784 
  def __ne__(self, other):
7785 
    return not (self == other)
7786 
 
483 rajveer 7787 
class getAllOrders_args:
94 ashish 7788 
  """
7789 
  Attributes:
4801 anupam.sin 7790 
   - statuses
483 rajveer 7791 
   - from_date
7792 
   - to_date
7793 
   - warehouse_id
94 ashish 7794 
  """
7795 
 
7796 
  thrift_spec = (
7797 
    None, # 0
4801 anupam.sin 7798 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7799 
    (2, TType.I64, 'from_date', None, None, ), # 2
7800 
    (3, TType.I64, 'to_date', None, None, ), # 3
7801 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7802 
  )
7803 
 
4801 anupam.sin 7804 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7805 
    self.statuses = statuses
483 rajveer 7806 
    self.from_date = from_date
7807 
    self.to_date = to_date
7808 
    self.warehouse_id = warehouse_id
94 ashish 7809 
 
7810 
  def read(self, iprot):
7811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7813 
      return
7814 
    iprot.readStructBegin()
7815 
    while True:
7816 
      (fname, ftype, fid) = iprot.readFieldBegin()
7817 
      if ftype == TType.STOP:
7818 
        break
7819 
      if fid == 1:
4801 anupam.sin 7820 
        if ftype == TType.LIST:
7821 
          self.statuses = []
5031 varun.gupt 7822 
          (_etype80, _size77) = iprot.readListBegin()
7823 
          for _i81 in xrange(_size77):
7824 
            _elem82 = iprot.readI32();
7825 
            self.statuses.append(_elem82)
4801 anupam.sin 7826 
          iprot.readListEnd()
94 ashish 7827 
        else:
7828 
          iprot.skip(ftype)
483 rajveer 7829 
      elif fid == 2:
7830 
        if ftype == TType.I64:
7831 
          self.from_date = iprot.readI64();
94 ashish 7832 
        else:
7833 
          iprot.skip(ftype)
483 rajveer 7834 
      elif fid == 3:
7835 
        if ftype == TType.I64:
7836 
          self.to_date = iprot.readI64();
94 ashish 7837 
        else:
7838 
          iprot.skip(ftype)
483 rajveer 7839 
      elif fid == 4:
94 ashish 7840 
        if ftype == TType.I64:
483 rajveer 7841 
          self.warehouse_id = iprot.readI64();
94 ashish 7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      else:
7845 
        iprot.skip(ftype)
7846 
      iprot.readFieldEnd()
7847 
    iprot.readStructEnd()
7848 
 
7849 
  def write(self, oprot):
7850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7852 
      return
483 rajveer 7853 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7854 
    if self.statuses is not None:
7855 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7856 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7857 
      for iter83 in self.statuses:
7858 
        oprot.writeI32(iter83)
4801 anupam.sin 7859 
      oprot.writeListEnd()
94 ashish 7860 
      oprot.writeFieldEnd()
3431 rajveer 7861 
    if self.from_date is not None:
483 rajveer 7862 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7863 
      oprot.writeI64(self.from_date)
94 ashish 7864 
      oprot.writeFieldEnd()
3431 rajveer 7865 
    if self.to_date is not None:
483 rajveer 7866 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7867 
      oprot.writeI64(self.to_date)
94 ashish 7868 
      oprot.writeFieldEnd()
3431 rajveer 7869 
    if self.warehouse_id is not None:
483 rajveer 7870 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7871 
      oprot.writeI64(self.warehouse_id)
94 ashish 7872 
      oprot.writeFieldEnd()
7873 
    oprot.writeFieldStop()
7874 
    oprot.writeStructEnd()
7875 
 
3431 rajveer 7876 
  def validate(self):
7877 
    return
7878 
 
7879 
 
94 ashish 7880 
  def __repr__(self):
7881 
    L = ['%s=%r' % (key, value)
7882 
      for key, value in self.__dict__.iteritems()]
7883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7884 
 
7885 
  def __eq__(self, other):
7886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7887 
 
7888 
  def __ne__(self, other):
7889 
    return not (self == other)
7890 
 
483 rajveer 7891 
class getAllOrders_result:
94 ashish 7892 
  """
7893 
  Attributes:
7894 
   - success
7895 
   - ex
7896 
  """
7897 
 
7898 
  thrift_spec = (
483 rajveer 7899 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7901 
  )
7902 
 
7903 
  def __init__(self, success=None, ex=None,):
7904 
    self.success = success
7905 
    self.ex = ex
7906 
 
7907 
  def read(self, iprot):
7908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7910 
      return
7911 
    iprot.readStructBegin()
7912 
    while True:
7913 
      (fname, ftype, fid) = iprot.readFieldBegin()
7914 
      if ftype == TType.STOP:
7915 
        break
7916 
      if fid == 0:
483 rajveer 7917 
        if ftype == TType.LIST:
7918 
          self.success = []
5031 varun.gupt 7919 
          (_etype87, _size84) = iprot.readListBegin()
7920 
          for _i88 in xrange(_size84):
7921 
            _elem89 = Order()
7922 
            _elem89.read(iprot)
7923 
            self.success.append(_elem89)
483 rajveer 7924 
          iprot.readListEnd()
94 ashish 7925 
        else:
7926 
          iprot.skip(ftype)
7927 
      elif fid == 1:
7928 
        if ftype == TType.STRUCT:
7929 
          self.ex = TransactionServiceException()
7930 
          self.ex.read(iprot)
7931 
        else:
7932 
          iprot.skip(ftype)
7933 
      else:
7934 
        iprot.skip(ftype)
7935 
      iprot.readFieldEnd()
7936 
    iprot.readStructEnd()
7937 
 
7938 
  def write(self, oprot):
7939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7941 
      return
483 rajveer 7942 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7943 
    if self.success is not None:
483 rajveer 7944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7946 
      for iter90 in self.success:
7947 
        iter90.write(oprot)
483 rajveer 7948 
      oprot.writeListEnd()
94 ashish 7949 
      oprot.writeFieldEnd()
3431 rajveer 7950 
    if self.ex is not None:
94 ashish 7951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7952 
      self.ex.write(oprot)
7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
3431 rajveer 7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
94 ashish 7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
4133 chandransh 7972 
class getOrdersInBatch_args:
7973 
  """
7974 
  Attributes:
7975 
   - statuses
7976 
   - offset
7977 
   - limit
7978 
   - warehouse_id
7979 
  """
7980 
 
7981 
  thrift_spec = (
7982 
    None, # 0
7983 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7984 
    (2, TType.I64, 'offset', None, None, ), # 2
7985 
    (3, TType.I64, 'limit', None, None, ), # 3
7986 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7987 
  )
7988 
 
7989 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7990 
    self.statuses = statuses
7991 
    self.offset = offset
7992 
    self.limit = limit
7993 
    self.warehouse_id = warehouse_id
7994 
 
7995 
  def read(self, iprot):
7996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7998 
      return
7999 
    iprot.readStructBegin()
8000 
    while True:
8001 
      (fname, ftype, fid) = iprot.readFieldBegin()
8002 
      if ftype == TType.STOP:
8003 
        break
8004 
      if fid == 1:
8005 
        if ftype == TType.LIST:
8006 
          self.statuses = []
5031 varun.gupt 8007 
          (_etype94, _size91) = iprot.readListBegin()
8008 
          for _i95 in xrange(_size91):
8009 
            _elem96 = iprot.readI32();
8010 
            self.statuses.append(_elem96)
4133 chandransh 8011 
          iprot.readListEnd()
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      elif fid == 2:
8015 
        if ftype == TType.I64:
8016 
          self.offset = iprot.readI64();
8017 
        else:
8018 
          iprot.skip(ftype)
8019 
      elif fid == 3:
8020 
        if ftype == TType.I64:
8021 
          self.limit = iprot.readI64();
8022 
        else:
8023 
          iprot.skip(ftype)
8024 
      elif fid == 4:
8025 
        if ftype == TType.I64:
8026 
          self.warehouse_id = iprot.readI64();
8027 
        else:
8028 
          iprot.skip(ftype)
8029 
      else:
8030 
        iprot.skip(ftype)
8031 
      iprot.readFieldEnd()
8032 
    iprot.readStructEnd()
8033 
 
8034 
  def write(self, oprot):
8035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8037 
      return
8038 
    oprot.writeStructBegin('getOrdersInBatch_args')
8039 
    if self.statuses is not None:
8040 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8041 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8042 
      for iter97 in self.statuses:
8043 
        oprot.writeI32(iter97)
4133 chandransh 8044 
      oprot.writeListEnd()
8045 
      oprot.writeFieldEnd()
8046 
    if self.offset is not None:
8047 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8048 
      oprot.writeI64(self.offset)
8049 
      oprot.writeFieldEnd()
8050 
    if self.limit is not None:
8051 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8052 
      oprot.writeI64(self.limit)
8053 
      oprot.writeFieldEnd()
8054 
    if self.warehouse_id is not None:
8055 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8056 
      oprot.writeI64(self.warehouse_id)
8057 
      oprot.writeFieldEnd()
8058 
    oprot.writeFieldStop()
8059 
    oprot.writeStructEnd()
8060 
 
8061 
  def validate(self):
8062 
    return
8063 
 
8064 
 
8065 
  def __repr__(self):
8066 
    L = ['%s=%r' % (key, value)
8067 
      for key, value in self.__dict__.iteritems()]
8068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8069 
 
8070 
  def __eq__(self, other):
8071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8072 
 
8073 
  def __ne__(self, other):
8074 
    return not (self == other)
8075 
 
8076 
class getOrdersInBatch_result:
8077 
  """
8078 
  Attributes:
8079 
   - success
8080 
   - ex
8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8086 
  )
8087 
 
8088 
  def __init__(self, success=None, ex=None,):
8089 
    self.success = success
8090 
    self.ex = ex
8091 
 
8092 
  def read(self, iprot):
8093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8095 
      return
8096 
    iprot.readStructBegin()
8097 
    while True:
8098 
      (fname, ftype, fid) = iprot.readFieldBegin()
8099 
      if ftype == TType.STOP:
8100 
        break
8101 
      if fid == 0:
8102 
        if ftype == TType.LIST:
8103 
          self.success = []
5031 varun.gupt 8104 
          (_etype101, _size98) = iprot.readListBegin()
8105 
          for _i102 in xrange(_size98):
8106 
            _elem103 = Order()
8107 
            _elem103.read(iprot)
8108 
            self.success.append(_elem103)
4133 chandransh 8109 
          iprot.readListEnd()
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      elif fid == 1:
8113 
        if ftype == TType.STRUCT:
8114 
          self.ex = TransactionServiceException()
8115 
          self.ex.read(iprot)
8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      else:
8119 
        iprot.skip(ftype)
8120 
      iprot.readFieldEnd()
8121 
    iprot.readStructEnd()
8122 
 
8123 
  def write(self, oprot):
8124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8126 
      return
8127 
    oprot.writeStructBegin('getOrdersInBatch_result')
8128 
    if self.success is not None:
8129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8130 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8131 
      for iter104 in self.success:
8132 
        iter104.write(oprot)
4133 chandransh 8133 
      oprot.writeListEnd()
8134 
      oprot.writeFieldEnd()
8135 
    if self.ex is not None:
8136 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8137 
      self.ex.write(oprot)
8138 
      oprot.writeFieldEnd()
8139 
    oprot.writeFieldStop()
8140 
    oprot.writeStructEnd()
8141 
 
8142 
  def validate(self):
8143 
    return
8144 
 
8145 
 
8146 
  def __repr__(self):
8147 
    L = ['%s=%r' % (key, value)
8148 
      for key, value in self.__dict__.iteritems()]
8149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8150 
 
8151 
  def __eq__(self, other):
8152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8153 
 
8154 
  def __ne__(self, other):
8155 
    return not (self == other)
8156 
 
8157 
class getOrderCount_args:
8158 
  """
8159 
  Attributes:
8160 
   - statuses
8161 
   - warehouseId
8162 
  """
8163 
 
8164 
  thrift_spec = (
8165 
    None, # 0
8166 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8167 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8168 
  )
8169 
 
8170 
  def __init__(self, statuses=None, warehouseId=None,):
8171 
    self.statuses = statuses
8172 
    self.warehouseId = warehouseId
8173 
 
8174 
  def read(self, iprot):
8175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8177 
      return
8178 
    iprot.readStructBegin()
8179 
    while True:
8180 
      (fname, ftype, fid) = iprot.readFieldBegin()
8181 
      if ftype == TType.STOP:
8182 
        break
8183 
      if fid == 1:
8184 
        if ftype == TType.LIST:
8185 
          self.statuses = []
5031 varun.gupt 8186 
          (_etype108, _size105) = iprot.readListBegin()
8187 
          for _i109 in xrange(_size105):
8188 
            _elem110 = iprot.readI32();
8189 
            self.statuses.append(_elem110)
4133 chandransh 8190 
          iprot.readListEnd()
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      elif fid == 2:
8194 
        if ftype == TType.I64:
8195 
          self.warehouseId = iprot.readI64();
8196 
        else:
8197 
          iprot.skip(ftype)
8198 
      else:
8199 
        iprot.skip(ftype)
8200 
      iprot.readFieldEnd()
8201 
    iprot.readStructEnd()
8202 
 
8203 
  def write(self, oprot):
8204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8206 
      return
8207 
    oprot.writeStructBegin('getOrderCount_args')
8208 
    if self.statuses is not None:
8209 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8210 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8211 
      for iter111 in self.statuses:
8212 
        oprot.writeI32(iter111)
4133 chandransh 8213 
      oprot.writeListEnd()
8214 
      oprot.writeFieldEnd()
8215 
    if self.warehouseId is not None:
8216 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8217 
      oprot.writeI64(self.warehouseId)
8218 
      oprot.writeFieldEnd()
8219 
    oprot.writeFieldStop()
8220 
    oprot.writeStructEnd()
8221 
 
8222 
  def validate(self):
8223 
    return
8224 
 
8225 
 
8226 
  def __repr__(self):
8227 
    L = ['%s=%r' % (key, value)
8228 
      for key, value in self.__dict__.iteritems()]
8229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8230 
 
8231 
  def __eq__(self, other):
8232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8233 
 
8234 
  def __ne__(self, other):
8235 
    return not (self == other)
8236 
 
8237 
class getOrderCount_result:
8238 
  """
8239 
  Attributes:
8240 
   - success
8241 
   - ex
8242 
  """
8243 
 
8244 
  thrift_spec = (
8245 
    (0, TType.I32, 'success', None, None, ), # 0
8246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8247 
  )
8248 
 
8249 
  def __init__(self, success=None, ex=None,):
8250 
    self.success = success
8251 
    self.ex = ex
8252 
 
8253 
  def read(self, iprot):
8254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8256 
      return
8257 
    iprot.readStructBegin()
8258 
    while True:
8259 
      (fname, ftype, fid) = iprot.readFieldBegin()
8260 
      if ftype == TType.STOP:
8261 
        break
8262 
      if fid == 0:
8263 
        if ftype == TType.I32:
8264 
          self.success = iprot.readI32();
8265 
        else:
8266 
          iprot.skip(ftype)
8267 
      elif fid == 1:
8268 
        if ftype == TType.STRUCT:
8269 
          self.ex = TransactionServiceException()
8270 
          self.ex.read(iprot)
8271 
        else:
8272 
          iprot.skip(ftype)
8273 
      else:
8274 
        iprot.skip(ftype)
8275 
      iprot.readFieldEnd()
8276 
    iprot.readStructEnd()
8277 
 
8278 
  def write(self, oprot):
8279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8281 
      return
8282 
    oprot.writeStructBegin('getOrderCount_result')
8283 
    if self.success is not None:
8284 
      oprot.writeFieldBegin('success', TType.I32, 0)
8285 
      oprot.writeI32(self.success)
8286 
      oprot.writeFieldEnd()
8287 
    if self.ex is not None:
8288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8289 
      self.ex.write(oprot)
8290 
      oprot.writeFieldEnd()
8291 
    oprot.writeFieldStop()
8292 
    oprot.writeStructEnd()
8293 
 
8294 
  def validate(self):
8295 
    return
8296 
 
8297 
 
8298 
  def __repr__(self):
8299 
    L = ['%s=%r' % (key, value)
8300 
      for key, value in self.__dict__.iteritems()]
8301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8302 
 
8303 
  def __eq__(self, other):
8304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8305 
 
8306 
  def __ne__(self, other):
8307 
    return not (self == other)
8308 
 
999 varun.gupt 8309 
class getOrdersByBillingDate_args:
8310 
  """
8311 
  Attributes:
8312 
   - status
8313 
   - start_billing_date
8314 
   - end_billing_date
8315 
   - warehouse_id
8316 
  """
8317 
 
8318 
  thrift_spec = (
8319 
    None, # 0
8320 
    (1, TType.I32, 'status', None, None, ), # 1
8321 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8322 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8323 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8324 
  )
8325 
 
8326 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8327 
    self.status = status
8328 
    self.start_billing_date = start_billing_date
8329 
    self.end_billing_date = end_billing_date
8330 
    self.warehouse_id = warehouse_id
8331 
 
8332 
  def read(self, iprot):
8333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8335 
      return
8336 
    iprot.readStructBegin()
8337 
    while True:
8338 
      (fname, ftype, fid) = iprot.readFieldBegin()
8339 
      if ftype == TType.STOP:
8340 
        break
8341 
      if fid == 1:
8342 
        if ftype == TType.I32:
8343 
          self.status = iprot.readI32();
8344 
        else:
8345 
          iprot.skip(ftype)
8346 
      elif fid == 2:
8347 
        if ftype == TType.I64:
8348 
          self.start_billing_date = iprot.readI64();
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      elif fid == 3:
8352 
        if ftype == TType.I64:
8353 
          self.end_billing_date = iprot.readI64();
8354 
        else:
8355 
          iprot.skip(ftype)
8356 
      elif fid == 4:
8357 
        if ftype == TType.I64:
8358 
          self.warehouse_id = iprot.readI64();
8359 
        else:
8360 
          iprot.skip(ftype)
8361 
      else:
8362 
        iprot.skip(ftype)
8363 
      iprot.readFieldEnd()
8364 
    iprot.readStructEnd()
8365 
 
8366 
  def write(self, oprot):
8367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8369 
      return
8370 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8371 
    if self.status is not None:
999 varun.gupt 8372 
      oprot.writeFieldBegin('status', TType.I32, 1)
8373 
      oprot.writeI32(self.status)
8374 
      oprot.writeFieldEnd()
3431 rajveer 8375 
    if self.start_billing_date is not None:
999 varun.gupt 8376 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8377 
      oprot.writeI64(self.start_billing_date)
8378 
      oprot.writeFieldEnd()
3431 rajveer 8379 
    if self.end_billing_date is not None:
999 varun.gupt 8380 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8381 
      oprot.writeI64(self.end_billing_date)
8382 
      oprot.writeFieldEnd()
3431 rajveer 8383 
    if self.warehouse_id is not None:
999 varun.gupt 8384 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8385 
      oprot.writeI64(self.warehouse_id)
8386 
      oprot.writeFieldEnd()
8387 
    oprot.writeFieldStop()
8388 
    oprot.writeStructEnd()
8389 
 
3431 rajveer 8390 
  def validate(self):
8391 
    return
8392 
 
8393 
 
999 varun.gupt 8394 
  def __repr__(self):
8395 
    L = ['%s=%r' % (key, value)
8396 
      for key, value in self.__dict__.iteritems()]
8397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8398 
 
8399 
  def __eq__(self, other):
8400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8401 
 
8402 
  def __ne__(self, other):
8403 
    return not (self == other)
8404 
 
8405 
class getOrdersByBillingDate_result:
8406 
  """
8407 
  Attributes:
8408 
   - success
8409 
   - ex
8410 
  """
8411 
 
8412 
  thrift_spec = (
8413 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8415 
  )
8416 
 
8417 
  def __init__(self, success=None, ex=None,):
8418 
    self.success = success
8419 
    self.ex = ex
8420 
 
8421 
  def read(self, iprot):
8422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8424 
      return
8425 
    iprot.readStructBegin()
8426 
    while True:
8427 
      (fname, ftype, fid) = iprot.readFieldBegin()
8428 
      if ftype == TType.STOP:
8429 
        break
8430 
      if fid == 0:
8431 
        if ftype == TType.LIST:
8432 
          self.success = []
5031 varun.gupt 8433 
          (_etype115, _size112) = iprot.readListBegin()
8434 
          for _i116 in xrange(_size112):
8435 
            _elem117 = Order()
8436 
            _elem117.read(iprot)
8437 
            self.success.append(_elem117)
999 varun.gupt 8438 
          iprot.readListEnd()
8439 
        else:
8440 
          iprot.skip(ftype)
8441 
      elif fid == 1:
8442 
        if ftype == TType.STRUCT:
8443 
          self.ex = TransactionServiceException()
8444 
          self.ex.read(iprot)
8445 
        else:
8446 
          iprot.skip(ftype)
8447 
      else:
8448 
        iprot.skip(ftype)
8449 
      iprot.readFieldEnd()
8450 
    iprot.readStructEnd()
8451 
 
8452 
  def write(self, oprot):
8453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8455 
      return
8456 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8457 
    if self.success is not None:
999 varun.gupt 8458 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8459 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8460 
      for iter118 in self.success:
8461 
        iter118.write(oprot)
999 varun.gupt 8462 
      oprot.writeListEnd()
8463 
      oprot.writeFieldEnd()
3431 rajveer 8464 
    if self.ex is not None:
999 varun.gupt 8465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8466 
      self.ex.write(oprot)
8467 
      oprot.writeFieldEnd()
8468 
    oprot.writeFieldStop()
8469 
    oprot.writeStructEnd()
8470 
 
3431 rajveer 8471 
  def validate(self):
8472 
    return
8473 
 
8474 
 
999 varun.gupt 8475 
  def __repr__(self):
8476 
    L = ['%s=%r' % (key, value)
8477 
      for key, value in self.__dict__.iteritems()]
8478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8479 
 
8480 
  def __eq__(self, other):
8481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8482 
 
8483 
  def __ne__(self, other):
8484 
    return not (self == other)
8485 
 
3427 chandransh 8486 
class getOrdersByShippingDate_args:
8487 
  """
8488 
  Attributes:
8489 
   - fromShippingDate
8490 
   - toShippingDate
8491 
   - providerId
8492 
   - warehouseId
3451 chandransh 8493 
   - cod
3427 chandransh 8494 
  """
8495 
 
8496 
  thrift_spec = (
8497 
    None, # 0
8498 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8499 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8500 
    (3, TType.I64, 'providerId', None, None, ), # 3
8501 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8502 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8503 
  )
8504 
 
3451 chandransh 8505 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8506 
    self.fromShippingDate = fromShippingDate
8507 
    self.toShippingDate = toShippingDate
8508 
    self.providerId = providerId
8509 
    self.warehouseId = warehouseId
3451 chandransh 8510 
    self.cod = cod
3427 chandransh 8511 
 
8512 
  def read(self, iprot):
8513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8515 
      return
8516 
    iprot.readStructBegin()
8517 
    while True:
8518 
      (fname, ftype, fid) = iprot.readFieldBegin()
8519 
      if ftype == TType.STOP:
8520 
        break
8521 
      if fid == 1:
8522 
        if ftype == TType.I64:
8523 
          self.fromShippingDate = iprot.readI64();
8524 
        else:
8525 
          iprot.skip(ftype)
8526 
      elif fid == 2:
8527 
        if ftype == TType.I64:
8528 
          self.toShippingDate = iprot.readI64();
8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      elif fid == 3:
8532 
        if ftype == TType.I64:
8533 
          self.providerId = iprot.readI64();
8534 
        else:
8535 
          iprot.skip(ftype)
8536 
      elif fid == 4:
8537 
        if ftype == TType.I64:
8538 
          self.warehouseId = iprot.readI64();
8539 
        else:
8540 
          iprot.skip(ftype)
3451 chandransh 8541 
      elif fid == 5:
8542 
        if ftype == TType.BOOL:
8543 
          self.cod = iprot.readBool();
8544 
        else:
8545 
          iprot.skip(ftype)
3427 chandransh 8546 
      else:
8547 
        iprot.skip(ftype)
8548 
      iprot.readFieldEnd()
8549 
    iprot.readStructEnd()
8550 
 
8551 
  def write(self, oprot):
8552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8554 
      return
8555 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8556 
    if self.fromShippingDate is not None:
3427 chandransh 8557 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8558 
      oprot.writeI64(self.fromShippingDate)
8559 
      oprot.writeFieldEnd()
3431 rajveer 8560 
    if self.toShippingDate is not None:
3427 chandransh 8561 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8562 
      oprot.writeI64(self.toShippingDate)
8563 
      oprot.writeFieldEnd()
3431 rajveer 8564 
    if self.providerId is not None:
3427 chandransh 8565 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8566 
      oprot.writeI64(self.providerId)
8567 
      oprot.writeFieldEnd()
3431 rajveer 8568 
    if self.warehouseId is not None:
3427 chandransh 8569 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8570 
      oprot.writeI64(self.warehouseId)
8571 
      oprot.writeFieldEnd()
3451 chandransh 8572 
    if self.cod is not None:
8573 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8574 
      oprot.writeBool(self.cod)
8575 
      oprot.writeFieldEnd()
3427 chandransh 8576 
    oprot.writeFieldStop()
8577 
    oprot.writeStructEnd()
8578 
 
3431 rajveer 8579 
  def validate(self):
8580 
    return
8581 
 
8582 
 
3427 chandransh 8583 
  def __repr__(self):
8584 
    L = ['%s=%r' % (key, value)
8585 
      for key, value in self.__dict__.iteritems()]
8586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8587 
 
8588 
  def __eq__(self, other):
8589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8590 
 
8591 
  def __ne__(self, other):
8592 
    return not (self == other)
8593 
 
8594 
class getOrdersByShippingDate_result:
8595 
  """
8596 
  Attributes:
8597 
   - success
8598 
   - ex
8599 
  """
8600 
 
8601 
  thrift_spec = (
8602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8604 
  )
8605 
 
8606 
  def __init__(self, success=None, ex=None,):
8607 
    self.success = success
8608 
    self.ex = ex
8609 
 
8610 
  def read(self, iprot):
8611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8613 
      return
8614 
    iprot.readStructBegin()
8615 
    while True:
8616 
      (fname, ftype, fid) = iprot.readFieldBegin()
8617 
      if ftype == TType.STOP:
8618 
        break
8619 
      if fid == 0:
8620 
        if ftype == TType.LIST:
8621 
          self.success = []
5031 varun.gupt 8622 
          (_etype122, _size119) = iprot.readListBegin()
8623 
          for _i123 in xrange(_size119):
8624 
            _elem124 = Order()
8625 
            _elem124.read(iprot)
8626 
            self.success.append(_elem124)
3427 chandransh 8627 
          iprot.readListEnd()
8628 
        else:
8629 
          iprot.skip(ftype)
8630 
      elif fid == 1:
8631 
        if ftype == TType.STRUCT:
8632 
          self.ex = TransactionServiceException()
8633 
          self.ex.read(iprot)
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      else:
8637 
        iprot.skip(ftype)
8638 
      iprot.readFieldEnd()
8639 
    iprot.readStructEnd()
8640 
 
8641 
  def write(self, oprot):
8642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8644 
      return
8645 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8646 
    if self.success is not None:
3427 chandransh 8647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8649 
      for iter125 in self.success:
8650 
        iter125.write(oprot)
3427 chandransh 8651 
      oprot.writeListEnd()
8652 
      oprot.writeFieldEnd()
3431 rajveer 8653 
    if self.ex is not None:
3427 chandransh 8654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8655 
      self.ex.write(oprot)
8656 
      oprot.writeFieldEnd()
8657 
    oprot.writeFieldStop()
8658 
    oprot.writeStructEnd()
8659 
 
3431 rajveer 8660 
  def validate(self):
8661 
    return
8662 
 
8663 
 
3427 chandransh 8664 
  def __repr__(self):
8665 
    L = ['%s=%r' % (key, value)
8666 
      for key, value in self.__dict__.iteritems()]
8667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8668 
 
8669 
  def __eq__(self, other):
8670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8671 
 
8672 
  def __ne__(self, other):
8673 
    return not (self == other)
8674 
 
1382 varun.gupt 8675 
class getReturnableOrdersForCustomer_args:
8676 
  """
8677 
  Attributes:
8678 
   - customer_id
8679 
   - limit
8680 
  """
8681 
 
8682 
  thrift_spec = (
8683 
    None, # 0
8684 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8685 
    (2, TType.I64, 'limit', None, None, ), # 2
8686 
  )
8687 
 
8688 
  def __init__(self, customer_id=None, limit=None,):
8689 
    self.customer_id = customer_id
8690 
    self.limit = limit
8691 
 
8692 
  def read(self, iprot):
8693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8695 
      return
8696 
    iprot.readStructBegin()
8697 
    while True:
8698 
      (fname, ftype, fid) = iprot.readFieldBegin()
8699 
      if ftype == TType.STOP:
8700 
        break
8701 
      if fid == 1:
8702 
        if ftype == TType.I64:
8703 
          self.customer_id = iprot.readI64();
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      elif fid == 2:
8707 
        if ftype == TType.I64:
8708 
          self.limit = iprot.readI64();
8709 
        else:
8710 
          iprot.skip(ftype)
8711 
      else:
8712 
        iprot.skip(ftype)
8713 
      iprot.readFieldEnd()
8714 
    iprot.readStructEnd()
8715 
 
8716 
  def write(self, oprot):
8717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8719 
      return
8720 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8721 
    if self.customer_id is not None:
1382 varun.gupt 8722 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8723 
      oprot.writeI64(self.customer_id)
8724 
      oprot.writeFieldEnd()
3431 rajveer 8725 
    if self.limit is not None:
1382 varun.gupt 8726 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8727 
      oprot.writeI64(self.limit)
8728 
      oprot.writeFieldEnd()
8729 
    oprot.writeFieldStop()
8730 
    oprot.writeStructEnd()
8731 
 
3431 rajveer 8732 
  def validate(self):
8733 
    return
8734 
 
8735 
 
1382 varun.gupt 8736 
  def __repr__(self):
8737 
    L = ['%s=%r' % (key, value)
8738 
      for key, value in self.__dict__.iteritems()]
8739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8740 
 
8741 
  def __eq__(self, other):
8742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8743 
 
8744 
  def __ne__(self, other):
8745 
    return not (self == other)
8746 
 
8747 
class getReturnableOrdersForCustomer_result:
8748 
  """
8749 
  Attributes:
8750 
   - success
8751 
   - ex
8752 
  """
8753 
 
8754 
  thrift_spec = (
8755 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8757 
  )
8758 
 
8759 
  def __init__(self, success=None, ex=None,):
8760 
    self.success = success
8761 
    self.ex = ex
8762 
 
8763 
  def read(self, iprot):
8764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8766 
      return
8767 
    iprot.readStructBegin()
8768 
    while True:
8769 
      (fname, ftype, fid) = iprot.readFieldBegin()
8770 
      if ftype == TType.STOP:
8771 
        break
8772 
      if fid == 0:
8773 
        if ftype == TType.LIST:
8774 
          self.success = []
5031 varun.gupt 8775 
          (_etype129, _size126) = iprot.readListBegin()
8776 
          for _i130 in xrange(_size126):
8777 
            _elem131 = iprot.readI64();
8778 
            self.success.append(_elem131)
1382 varun.gupt 8779 
          iprot.readListEnd()
8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      elif fid == 1:
8783 
        if ftype == TType.STRUCT:
8784 
          self.ex = TransactionServiceException()
8785 
          self.ex.read(iprot)
8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
8797 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8798 
    if self.success is not None:
1382 varun.gupt 8799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8800 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8801 
      for iter132 in self.success:
8802 
        oprot.writeI64(iter132)
1382 varun.gupt 8803 
      oprot.writeListEnd()
8804 
      oprot.writeFieldEnd()
3431 rajveer 8805 
    if self.ex is not None:
1382 varun.gupt 8806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8807 
      self.ex.write(oprot)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
3431 rajveer 8812 
  def validate(self):
8813 
    return
8814 
 
8815 
 
1382 varun.gupt 8816 
  def __repr__(self):
8817 
    L = ['%s=%r' % (key, value)
8818 
      for key, value in self.__dict__.iteritems()]
8819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8820 
 
8821 
  def __eq__(self, other):
8822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8823 
 
8824 
  def __ne__(self, other):
8825 
    return not (self == other)
8826 
 
8827 
class getCancellableOrdersForCustomer_args:
8828 
  """
8829 
  Attributes:
8830 
   - customer_id
8831 
   - limit
8832 
  """
8833 
 
8834 
  thrift_spec = (
8835 
    None, # 0
8836 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8837 
    (2, TType.I64, 'limit', None, None, ), # 2
8838 
  )
8839 
 
8840 
  def __init__(self, customer_id=None, limit=None,):
8841 
    self.customer_id = customer_id
8842 
    self.limit = limit
8843 
 
8844 
  def read(self, iprot):
8845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8847 
      return
8848 
    iprot.readStructBegin()
8849 
    while True:
8850 
      (fname, ftype, fid) = iprot.readFieldBegin()
8851 
      if ftype == TType.STOP:
8852 
        break
8853 
      if fid == 1:
8854 
        if ftype == TType.I64:
8855 
          self.customer_id = iprot.readI64();
8856 
        else:
8857 
          iprot.skip(ftype)
8858 
      elif fid == 2:
8859 
        if ftype == TType.I64:
8860 
          self.limit = iprot.readI64();
8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
8872 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8873 
    if self.customer_id is not None:
1382 varun.gupt 8874 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8875 
      oprot.writeI64(self.customer_id)
8876 
      oprot.writeFieldEnd()
3431 rajveer 8877 
    if self.limit is not None:
1382 varun.gupt 8878 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8879 
      oprot.writeI64(self.limit)
8880 
      oprot.writeFieldEnd()
8881 
    oprot.writeFieldStop()
8882 
    oprot.writeStructEnd()
8883 
 
3431 rajveer 8884 
  def validate(self):
8885 
    return
8886 
 
8887 
 
1382 varun.gupt 8888 
  def __repr__(self):
8889 
    L = ['%s=%r' % (key, value)
8890 
      for key, value in self.__dict__.iteritems()]
8891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8892 
 
8893 
  def __eq__(self, other):
8894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8895 
 
8896 
  def __ne__(self, other):
8897 
    return not (self == other)
8898 
 
8899 
class getCancellableOrdersForCustomer_result:
8900 
  """
8901 
  Attributes:
8902 
   - success
8903 
   - ex
8904 
  """
8905 
 
8906 
  thrift_spec = (
8907 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8909 
  )
8910 
 
8911 
  def __init__(self, success=None, ex=None,):
8912 
    self.success = success
8913 
    self.ex = ex
8914 
 
8915 
  def read(self, iprot):
8916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8918 
      return
8919 
    iprot.readStructBegin()
8920 
    while True:
8921 
      (fname, ftype, fid) = iprot.readFieldBegin()
8922 
      if ftype == TType.STOP:
8923 
        break
8924 
      if fid == 0:
8925 
        if ftype == TType.LIST:
8926 
          self.success = []
5031 varun.gupt 8927 
          (_etype136, _size133) = iprot.readListBegin()
8928 
          for _i137 in xrange(_size133):
8929 
            _elem138 = iprot.readI64();
8930 
            self.success.append(_elem138)
1382 varun.gupt 8931 
          iprot.readListEnd()
8932 
        else:
8933 
          iprot.skip(ftype)
8934 
      elif fid == 1:
8935 
        if ftype == TType.STRUCT:
8936 
          self.ex = TransactionServiceException()
8937 
          self.ex.read(iprot)
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      else:
8941 
        iprot.skip(ftype)
8942 
      iprot.readFieldEnd()
8943 
    iprot.readStructEnd()
8944 
 
8945 
  def write(self, oprot):
8946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8948 
      return
8949 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8950 
    if self.success is not None:
1382 varun.gupt 8951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8952 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8953 
      for iter139 in self.success:
8954 
        oprot.writeI64(iter139)
1382 varun.gupt 8955 
      oprot.writeListEnd()
8956 
      oprot.writeFieldEnd()
3431 rajveer 8957 
    if self.ex is not None:
1382 varun.gupt 8958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8959 
      self.ex.write(oprot)
8960 
      oprot.writeFieldEnd()
8961 
    oprot.writeFieldStop()
8962 
    oprot.writeStructEnd()
8963 
 
3431 rajveer 8964 
  def validate(self):
8965 
    return
8966 
 
8967 
 
1382 varun.gupt 8968 
  def __repr__(self):
8969 
    L = ['%s=%r' % (key, value)
8970 
      for key, value in self.__dict__.iteritems()]
8971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8972 
 
8973 
  def __eq__(self, other):
8974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8975 
 
8976 
  def __ne__(self, other):
8977 
    return not (self == other)
8978 
 
483 rajveer 8979 
class changeOrderStatus_args:
94 ashish 8980 
  """
8981 
  Attributes:
483 rajveer 8982 
   - orderId
8983 
   - status
8984 
   - description
94 ashish 8985 
  """
8986 
 
8987 
  thrift_spec = (
8988 
    None, # 0
483 rajveer 8989 
    (1, TType.I64, 'orderId', None, None, ), # 1
8990 
    (2, TType.I32, 'status', None, None, ), # 2
8991 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8992 
  )
8993 
 
483 rajveer 8994 
  def __init__(self, orderId=None, status=None, description=None,):
8995 
    self.orderId = orderId
8996 
    self.status = status
8997 
    self.description = description
94 ashish 8998 
 
8999 
  def read(self, iprot):
9000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9002 
      return
9003 
    iprot.readStructBegin()
9004 
    while True:
9005 
      (fname, ftype, fid) = iprot.readFieldBegin()
9006 
      if ftype == TType.STOP:
9007 
        break
9008 
      if fid == 1:
9009 
        if ftype == TType.I64:
483 rajveer 9010 
          self.orderId = iprot.readI64();
94 ashish 9011 
        else:
9012 
          iprot.skip(ftype)
9013 
      elif fid == 2:
483 rajveer 9014 
        if ftype == TType.I32:
9015 
          self.status = iprot.readI32();
94 ashish 9016 
        else:
9017 
          iprot.skip(ftype)
483 rajveer 9018 
      elif fid == 3:
9019 
        if ftype == TType.STRING:
9020 
          self.description = iprot.readString();
9021 
        else:
9022 
          iprot.skip(ftype)
94 ashish 9023 
      else:
9024 
        iprot.skip(ftype)
9025 
      iprot.readFieldEnd()
9026 
    iprot.readStructEnd()
9027 
 
9028 
  def write(self, oprot):
9029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9031 
      return
483 rajveer 9032 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9033 
    if self.orderId is not None:
483 rajveer 9034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9035 
      oprot.writeI64(self.orderId)
94 ashish 9036 
      oprot.writeFieldEnd()
3431 rajveer 9037 
    if self.status is not None:
483 rajveer 9038 
      oprot.writeFieldBegin('status', TType.I32, 2)
9039 
      oprot.writeI32(self.status)
94 ashish 9040 
      oprot.writeFieldEnd()
3431 rajveer 9041 
    if self.description is not None:
483 rajveer 9042 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9043 
      oprot.writeString(self.description)
9044 
      oprot.writeFieldEnd()
94 ashish 9045 
    oprot.writeFieldStop()
9046 
    oprot.writeStructEnd()
9047 
 
3431 rajveer 9048 
  def validate(self):
9049 
    return
9050 
 
9051 
 
94 ashish 9052 
  def __repr__(self):
9053 
    L = ['%s=%r' % (key, value)
9054 
      for key, value in self.__dict__.iteritems()]
9055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9056 
 
9057 
  def __eq__(self, other):
9058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9059 
 
9060 
  def __ne__(self, other):
9061 
    return not (self == other)
9062 
 
483 rajveer 9063 
class changeOrderStatus_result:
94 ashish 9064 
  """
9065 
  Attributes:
9066 
   - success
9067 
   - ex
9068 
  """
9069 
 
9070 
  thrift_spec = (
9071 
    (0, TType.BOOL, 'success', None, None, ), # 0
9072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9073 
  )
9074 
 
9075 
  def __init__(self, success=None, ex=None,):
9076 
    self.success = success
9077 
    self.ex = ex
9078 
 
9079 
  def read(self, iprot):
9080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9082 
      return
9083 
    iprot.readStructBegin()
9084 
    while True:
9085 
      (fname, ftype, fid) = iprot.readFieldBegin()
9086 
      if ftype == TType.STOP:
9087 
        break
9088 
      if fid == 0:
9089 
        if ftype == TType.BOOL:
9090 
          self.success = iprot.readBool();
9091 
        else:
9092 
          iprot.skip(ftype)
9093 
      elif fid == 1:
9094 
        if ftype == TType.STRUCT:
9095 
          self.ex = TransactionServiceException()
9096 
          self.ex.read(iprot)
9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      else:
9100 
        iprot.skip(ftype)
9101 
      iprot.readFieldEnd()
9102 
    iprot.readStructEnd()
9103 
 
9104 
  def write(self, oprot):
9105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9107 
      return
483 rajveer 9108 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9109 
    if self.success is not None:
94 ashish 9110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9111 
      oprot.writeBool(self.success)
9112 
      oprot.writeFieldEnd()
3431 rajveer 9113 
    if self.ex is not None:
94 ashish 9114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9115 
      self.ex.write(oprot)
9116 
      oprot.writeFieldEnd()
9117 
    oprot.writeFieldStop()
9118 
    oprot.writeStructEnd()
9119 
 
3431 rajveer 9120 
  def validate(self):
9121 
    return
9122 
 
9123 
 
94 ashish 9124 
  def __repr__(self):
9125 
    L = ['%s=%r' % (key, value)
9126 
      for key, value in self.__dict__.iteritems()]
9127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9128 
 
9129 
  def __eq__(self, other):
9130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9131 
 
9132 
  def __ne__(self, other):
9133 
    return not (self == other)
9134 
 
3064 chandransh 9135 
class getOrdersForTransaction_args:
494 rajveer 9136 
  """
9137 
  Attributes:
3064 chandransh 9138 
   - transactionId
9139 
   - customerId
494 rajveer 9140 
  """
9141 
 
9142 
  thrift_spec = (
9143 
    None, # 0
3064 chandransh 9144 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9145 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9146 
  )
9147 
 
3064 chandransh 9148 
  def __init__(self, transactionId=None, customerId=None,):
9149 
    self.transactionId = transactionId
9150 
    self.customerId = customerId
494 rajveer 9151 
 
9152 
  def read(self, iprot):
9153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9155 
      return
9156 
    iprot.readStructBegin()
9157 
    while True:
9158 
      (fname, ftype, fid) = iprot.readFieldBegin()
9159 
      if ftype == TType.STOP:
9160 
        break
9161 
      if fid == 1:
9162 
        if ftype == TType.I64:
3064 chandransh 9163 
          self.transactionId = iprot.readI64();
494 rajveer 9164 
        else:
9165 
          iprot.skip(ftype)
9166 
      elif fid == 2:
3064 chandransh 9167 
        if ftype == TType.I64:
9168 
          self.customerId = iprot.readI64();
494 rajveer 9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      else:
9172 
        iprot.skip(ftype)
9173 
      iprot.readFieldEnd()
9174 
    iprot.readStructEnd()
9175 
 
9176 
  def write(self, oprot):
9177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9179 
      return
3064 chandransh 9180 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9181 
    if self.transactionId is not None:
3064 chandransh 9182 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9183 
      oprot.writeI64(self.transactionId)
494 rajveer 9184 
      oprot.writeFieldEnd()
3431 rajveer 9185 
    if self.customerId is not None:
3064 chandransh 9186 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9187 
      oprot.writeI64(self.customerId)
494 rajveer 9188 
      oprot.writeFieldEnd()
9189 
    oprot.writeFieldStop()
9190 
    oprot.writeStructEnd()
9191 
 
3431 rajveer 9192 
  def validate(self):
9193 
    return
9194 
 
9195 
 
494 rajveer 9196 
  def __repr__(self):
9197 
    L = ['%s=%r' % (key, value)
9198 
      for key, value in self.__dict__.iteritems()]
9199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9200 
 
9201 
  def __eq__(self, other):
9202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9203 
 
9204 
  def __ne__(self, other):
9205 
    return not (self == other)
9206 
 
3064 chandransh 9207 
class getOrdersForTransaction_result:
494 rajveer 9208 
  """
9209 
  Attributes:
9210 
   - success
9211 
   - ex
9212 
  """
9213 
 
9214 
  thrift_spec = (
3064 chandransh 9215 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9217 
  )
9218 
 
9219 
  def __init__(self, success=None, ex=None,):
9220 
    self.success = success
9221 
    self.ex = ex
9222 
 
9223 
  def read(self, iprot):
9224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9226 
      return
9227 
    iprot.readStructBegin()
9228 
    while True:
9229 
      (fname, ftype, fid) = iprot.readFieldBegin()
9230 
      if ftype == TType.STOP:
9231 
        break
9232 
      if fid == 0:
3064 chandransh 9233 
        if ftype == TType.LIST:
9234 
          self.success = []
5031 varun.gupt 9235 
          (_etype143, _size140) = iprot.readListBegin()
9236 
          for _i144 in xrange(_size140):
9237 
            _elem145 = Order()
9238 
            _elem145.read(iprot)
9239 
            self.success.append(_elem145)
3064 chandransh 9240 
          iprot.readListEnd()
494 rajveer 9241 
        else:
9242 
          iprot.skip(ftype)
9243 
      elif fid == 1:
9244 
        if ftype == TType.STRUCT:
9245 
          self.ex = TransactionServiceException()
9246 
          self.ex.read(iprot)
9247 
        else:
9248 
          iprot.skip(ftype)
9249 
      else:
9250 
        iprot.skip(ftype)
9251 
      iprot.readFieldEnd()
9252 
    iprot.readStructEnd()
9253 
 
9254 
  def write(self, oprot):
9255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9257 
      return
3064 chandransh 9258 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9259 
    if self.success is not None:
3064 chandransh 9260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9261 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9262 
      for iter146 in self.success:
9263 
        iter146.write(oprot)
3064 chandransh 9264 
      oprot.writeListEnd()
494 rajveer 9265 
      oprot.writeFieldEnd()
3431 rajveer 9266 
    if self.ex is not None:
494 rajveer 9267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9268 
      self.ex.write(oprot)
9269 
      oprot.writeFieldEnd()
9270 
    oprot.writeFieldStop()
9271 
    oprot.writeStructEnd()
9272 
 
3431 rajveer 9273 
  def validate(self):
9274 
    return
9275 
 
9276 
 
494 rajveer 9277 
  def __repr__(self):
9278 
    L = ['%s=%r' % (key, value)
9279 
      for key, value in self.__dict__.iteritems()]
9280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9281 
 
9282 
  def __eq__(self, other):
9283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9284 
 
9285 
  def __ne__(self, other):
9286 
    return not (self == other)
9287 
 
3064 chandransh 9288 
class getOrdersForCustomer_args:
1149 chandransh 9289 
  """
9290 
  Attributes:
3064 chandransh 9291 
   - customerId
9292 
   - from_date
9293 
   - to_date
9294 
   - statuses
1149 chandransh 9295 
  """
9296 
 
9297 
  thrift_spec = (
9298 
    None, # 0
3064 chandransh 9299 
    (1, TType.I64, 'customerId', None, None, ), # 1
9300 
    (2, TType.I64, 'from_date', None, None, ), # 2
9301 
    (3, TType.I64, 'to_date', None, None, ), # 3
9302 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9303 
  )
9304 
 
3064 chandransh 9305 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9306 
    self.customerId = customerId
9307 
    self.from_date = from_date
9308 
    self.to_date = to_date
9309 
    self.statuses = statuses
1149 chandransh 9310 
 
9311 
  def read(self, iprot):
9312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9314 
      return
9315 
    iprot.readStructBegin()
9316 
    while True:
9317 
      (fname, ftype, fid) = iprot.readFieldBegin()
9318 
      if ftype == TType.STOP:
9319 
        break
9320 
      if fid == 1:
9321 
        if ftype == TType.I64:
3064 chandransh 9322 
          self.customerId = iprot.readI64();
1149 chandransh 9323 
        else:
9324 
          iprot.skip(ftype)
9325 
      elif fid == 2:
9326 
        if ftype == TType.I64:
3064 chandransh 9327 
          self.from_date = iprot.readI64();
1149 chandransh 9328 
        else:
9329 
          iprot.skip(ftype)
2783 chandransh 9330 
      elif fid == 3:
9331 
        if ftype == TType.I64:
3064 chandransh 9332 
          self.to_date = iprot.readI64();
2783 chandransh 9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      elif fid == 4:
3064 chandransh 9336 
        if ftype == TType.LIST:
9337 
          self.statuses = []
5031 varun.gupt 9338 
          (_etype150, _size147) = iprot.readListBegin()
9339 
          for _i151 in xrange(_size147):
9340 
            _elem152 = iprot.readI32();
9341 
            self.statuses.append(_elem152)
3064 chandransh 9342 
          iprot.readListEnd()
2783 chandransh 9343 
        else:
9344 
          iprot.skip(ftype)
1149 chandransh 9345 
      else:
9346 
        iprot.skip(ftype)
9347 
      iprot.readFieldEnd()
9348 
    iprot.readStructEnd()
9349 
 
9350 
  def write(self, oprot):
9351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9353 
      return
3064 chandransh 9354 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9355 
    if self.customerId is not None:
3064 chandransh 9356 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9357 
      oprot.writeI64(self.customerId)
1149 chandransh 9358 
      oprot.writeFieldEnd()
3431 rajveer 9359 
    if self.from_date is not None:
3064 chandransh 9360 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9361 
      oprot.writeI64(self.from_date)
1149 chandransh 9362 
      oprot.writeFieldEnd()
3431 rajveer 9363 
    if self.to_date is not None:
3064 chandransh 9364 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9365 
      oprot.writeI64(self.to_date)
2783 chandransh 9366 
      oprot.writeFieldEnd()
3431 rajveer 9367 
    if self.statuses is not None:
3064 chandransh 9368 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9369 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9370 
      for iter153 in self.statuses:
9371 
        oprot.writeI32(iter153)
3064 chandransh 9372 
      oprot.writeListEnd()
2783 chandransh 9373 
      oprot.writeFieldEnd()
1149 chandransh 9374 
    oprot.writeFieldStop()
9375 
    oprot.writeStructEnd()
9376 
 
3431 rajveer 9377 
  def validate(self):
9378 
    return
9379 
 
9380 
 
1149 chandransh 9381 
  def __repr__(self):
9382 
    L = ['%s=%r' % (key, value)
9383 
      for key, value in self.__dict__.iteritems()]
9384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9385 
 
9386 
  def __eq__(self, other):
9387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9388 
 
9389 
  def __ne__(self, other):
9390 
    return not (self == other)
9391 
 
3064 chandransh 9392 
class getOrdersForCustomer_result:
1149 chandransh 9393 
  """
9394 
  Attributes:
9395 
   - success
9396 
   - ex
9397 
  """
9398 
 
9399 
  thrift_spec = (
3064 chandransh 9400 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9401 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9402 
  )
9403 
 
9404 
  def __init__(self, success=None, ex=None,):
9405 
    self.success = success
9406 
    self.ex = ex
9407 
 
9408 
  def read(self, iprot):
9409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9411 
      return
9412 
    iprot.readStructBegin()
9413 
    while True:
9414 
      (fname, ftype, fid) = iprot.readFieldBegin()
9415 
      if ftype == TType.STOP:
9416 
        break
9417 
      if fid == 0:
3064 chandransh 9418 
        if ftype == TType.LIST:
9419 
          self.success = []
5031 varun.gupt 9420 
          (_etype157, _size154) = iprot.readListBegin()
9421 
          for _i158 in xrange(_size154):
9422 
            _elem159 = Order()
9423 
            _elem159.read(iprot)
9424 
            self.success.append(_elem159)
3064 chandransh 9425 
          iprot.readListEnd()
1149 chandransh 9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      elif fid == 1:
9429 
        if ftype == TType.STRUCT:
9430 
          self.ex = TransactionServiceException()
9431 
          self.ex.read(iprot)
9432 
        else:
9433 
          iprot.skip(ftype)
9434 
      else:
9435 
        iprot.skip(ftype)
9436 
      iprot.readFieldEnd()
9437 
    iprot.readStructEnd()
9438 
 
9439 
  def write(self, oprot):
9440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9442 
      return
3064 chandransh 9443 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9444 
    if self.success is not None:
3064 chandransh 9445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9447 
      for iter160 in self.success:
9448 
        iter160.write(oprot)
3064 chandransh 9449 
      oprot.writeListEnd()
1149 chandransh 9450 
      oprot.writeFieldEnd()
3431 rajveer 9451 
    if self.ex is not None:
1149 chandransh 9452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9453 
      self.ex.write(oprot)
9454 
      oprot.writeFieldEnd()
9455 
    oprot.writeFieldStop()
9456 
    oprot.writeStructEnd()
9457 
 
3431 rajveer 9458 
  def validate(self):
9459 
    return
9460 
 
9461 
 
1149 chandransh 9462 
  def __repr__(self):
9463 
    L = ['%s=%r' % (key, value)
9464 
      for key, value in self.__dict__.iteritems()]
9465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9466 
 
9467 
  def __eq__(self, other):
9468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9469 
 
9470 
  def __ne__(self, other):
9471 
    return not (self == other)
9472 
 
3064 chandransh 9473 
class createOrder_args:
921 rajveer 9474 
  """
9475 
  Attributes:
3064 chandransh 9476 
   - order
921 rajveer 9477 
  """
9478 
 
9479 
  thrift_spec = (
9480 
    None, # 0
3064 chandransh 9481 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9482 
  )
9483 
 
3064 chandransh 9484 
  def __init__(self, order=None,):
9485 
    self.order = order
921 rajveer 9486 
 
9487 
  def read(self, iprot):
9488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9490 
      return
9491 
    iprot.readStructBegin()
9492 
    while True:
9493 
      (fname, ftype, fid) = iprot.readFieldBegin()
9494 
      if ftype == TType.STOP:
9495 
        break
9496 
      if fid == 1:
3064 chandransh 9497 
        if ftype == TType.STRUCT:
9498 
          self.order = Order()
9499 
          self.order.read(iprot)
921 rajveer 9500 
        else:
9501 
          iprot.skip(ftype)
9502 
      else:
9503 
        iprot.skip(ftype)
9504 
      iprot.readFieldEnd()
9505 
    iprot.readStructEnd()
9506 
 
9507 
  def write(self, oprot):
9508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9510 
      return
3064 chandransh 9511 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9512 
    if self.order is not None:
3064 chandransh 9513 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9514 
      self.order.write(oprot)
921 rajveer 9515 
      oprot.writeFieldEnd()
9516 
    oprot.writeFieldStop()
9517 
    oprot.writeStructEnd()
9518 
 
3431 rajveer 9519 
  def validate(self):
9520 
    return
9521 
 
9522 
 
921 rajveer 9523 
  def __repr__(self):
9524 
    L = ['%s=%r' % (key, value)
9525 
      for key, value in self.__dict__.iteritems()]
9526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9527 
 
9528 
  def __eq__(self, other):
9529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9530 
 
9531 
  def __ne__(self, other):
9532 
    return not (self == other)
9533 
 
3064 chandransh 9534 
class createOrder_result:
921 rajveer 9535 
  """
9536 
  Attributes:
9537 
   - success
9538 
   - ex
9539 
  """
9540 
 
9541 
  thrift_spec = (
3064 chandransh 9542 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9544 
  )
9545 
 
9546 
  def __init__(self, success=None, ex=None,):
9547 
    self.success = success
9548 
    self.ex = ex
9549 
 
9550 
  def read(self, iprot):
9551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9553 
      return
9554 
    iprot.readStructBegin()
9555 
    while True:
9556 
      (fname, ftype, fid) = iprot.readFieldBegin()
9557 
      if ftype == TType.STOP:
9558 
        break
9559 
      if fid == 0:
3064 chandransh 9560 
        if ftype == TType.I64:
9561 
          self.success = iprot.readI64();
921 rajveer 9562 
        else:
9563 
          iprot.skip(ftype)
9564 
      elif fid == 1:
9565 
        if ftype == TType.STRUCT:
9566 
          self.ex = TransactionServiceException()
9567 
          self.ex.read(iprot)
9568 
        else:
9569 
          iprot.skip(ftype)
9570 
      else:
9571 
        iprot.skip(ftype)
9572 
      iprot.readFieldEnd()
9573 
    iprot.readStructEnd()
9574 
 
9575 
  def write(self, oprot):
9576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9578 
      return
3064 chandransh 9579 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9580 
    if self.success is not None:
3064 chandransh 9581 
      oprot.writeFieldBegin('success', TType.I64, 0)
9582 
      oprot.writeI64(self.success)
921 rajveer 9583 
      oprot.writeFieldEnd()
3431 rajveer 9584 
    if self.ex is not None:
921 rajveer 9585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9586 
      self.ex.write(oprot)
9587 
      oprot.writeFieldEnd()
9588 
    oprot.writeFieldStop()
9589 
    oprot.writeStructEnd()
9590 
 
3431 rajveer 9591 
  def validate(self):
9592 
    return
9593 
 
9594 
 
921 rajveer 9595 
  def __repr__(self):
9596 
    L = ['%s=%r' % (key, value)
9597 
      for key, value in self.__dict__.iteritems()]
9598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9599 
 
9600 
  def __eq__(self, other):
9601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9602 
 
9603 
  def __ne__(self, other):
9604 
    return not (self == other)
9605 
 
3064 chandransh 9606 
class getOrder_args:
921 rajveer 9607 
  """
9608 
  Attributes:
3064 chandransh 9609 
   - id
921 rajveer 9610 
  """
9611 
 
9612 
  thrift_spec = (
9613 
    None, # 0
3064 chandransh 9614 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9615 
  )
9616 
 
3064 chandransh 9617 
  def __init__(self, id=None,):
9618 
    self.id = id
921 rajveer 9619 
 
9620 
  def read(self, iprot):
9621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9623 
      return
9624 
    iprot.readStructBegin()
9625 
    while True:
9626 
      (fname, ftype, fid) = iprot.readFieldBegin()
9627 
      if ftype == TType.STOP:
9628 
        break
9629 
      if fid == 1:
9630 
        if ftype == TType.I64:
3064 chandransh 9631 
          self.id = iprot.readI64();
921 rajveer 9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
3064 chandransh 9643 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9644 
    if self.id is not None:
3064 chandransh 9645 
      oprot.writeFieldBegin('id', TType.I64, 1)
9646 
      oprot.writeI64(self.id)
921 rajveer 9647 
      oprot.writeFieldEnd()
9648 
    oprot.writeFieldStop()
9649 
    oprot.writeStructEnd()
9650 
 
3431 rajveer 9651 
  def validate(self):
9652 
    return
9653 
 
9654 
 
921 rajveer 9655 
  def __repr__(self):
9656 
    L = ['%s=%r' % (key, value)
9657 
      for key, value in self.__dict__.iteritems()]
9658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9659 
 
9660 
  def __eq__(self, other):
9661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9662 
 
9663 
  def __ne__(self, other):
9664 
    return not (self == other)
9665 
 
3064 chandransh 9666 
class getOrder_result:
921 rajveer 9667 
  """
9668 
  Attributes:
9669 
   - success
9670 
   - ex
9671 
  """
9672 
 
9673 
  thrift_spec = (
3064 chandransh 9674 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9676 
  )
9677 
 
9678 
  def __init__(self, success=None, ex=None,):
9679 
    self.success = success
9680 
    self.ex = ex
9681 
 
9682 
  def read(self, iprot):
9683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9685 
      return
9686 
    iprot.readStructBegin()
9687 
    while True:
9688 
      (fname, ftype, fid) = iprot.readFieldBegin()
9689 
      if ftype == TType.STOP:
9690 
        break
9691 
      if fid == 0:
3064 chandransh 9692 
        if ftype == TType.STRUCT:
9693 
          self.success = Order()
9694 
          self.success.read(iprot)
921 rajveer 9695 
        else:
9696 
          iprot.skip(ftype)
9697 
      elif fid == 1:
9698 
        if ftype == TType.STRUCT:
9699 
          self.ex = TransactionServiceException()
9700 
          self.ex.read(iprot)
9701 
        else:
9702 
          iprot.skip(ftype)
9703 
      else:
9704 
        iprot.skip(ftype)
9705 
      iprot.readFieldEnd()
9706 
    iprot.readStructEnd()
9707 
 
9708 
  def write(self, oprot):
9709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9711 
      return
3064 chandransh 9712 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9713 
    if self.success is not None:
3064 chandransh 9714 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9715 
      self.success.write(oprot)
921 rajveer 9716 
      oprot.writeFieldEnd()
3431 rajveer 9717 
    if self.ex is not None:
921 rajveer 9718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9719 
      self.ex.write(oprot)
9720 
      oprot.writeFieldEnd()
9721 
    oprot.writeFieldStop()
9722 
    oprot.writeStructEnd()
9723 
 
3431 rajveer 9724 
  def validate(self):
9725 
    return
9726 
 
9727 
 
921 rajveer 9728 
  def __repr__(self):
9729 
    L = ['%s=%r' % (key, value)
9730 
      for key, value in self.__dict__.iteritems()]
9731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9732 
 
9733 
  def __eq__(self, other):
9734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9735 
 
9736 
  def __ne__(self, other):
9737 
    return not (self == other)
9738 
 
3064 chandransh 9739 
class getLineItemsForOrder_args:
94 ashish 9740 
  """
9741 
  Attributes:
3064 chandransh 9742 
   - orderId
94 ashish 9743 
  """
9744 
 
9745 
  thrift_spec = (
9746 
    None, # 0
3064 chandransh 9747 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9748 
  )
9749 
 
3064 chandransh 9750 
  def __init__(self, orderId=None,):
9751 
    self.orderId = orderId
94 ashish 9752 
 
9753 
  def read(self, iprot):
9754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9756 
      return
9757 
    iprot.readStructBegin()
9758 
    while True:
9759 
      (fname, ftype, fid) = iprot.readFieldBegin()
9760 
      if ftype == TType.STOP:
9761 
        break
9762 
      if fid == 1:
9763 
        if ftype == TType.I64:
3064 chandransh 9764 
          self.orderId = iprot.readI64();
94 ashish 9765 
        else:
9766 
          iprot.skip(ftype)
9767 
      else:
9768 
        iprot.skip(ftype)
9769 
      iprot.readFieldEnd()
9770 
    iprot.readStructEnd()
9771 
 
9772 
  def write(self, oprot):
9773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9775 
      return
3064 chandransh 9776 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9777 
    if self.orderId is not None:
3064 chandransh 9778 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9779 
      oprot.writeI64(self.orderId)
94 ashish 9780 
      oprot.writeFieldEnd()
9781 
    oprot.writeFieldStop()
9782 
    oprot.writeStructEnd()
9783 
 
3431 rajveer 9784 
  def validate(self):
9785 
    return
9786 
 
9787 
 
94 ashish 9788 
  def __repr__(self):
9789 
    L = ['%s=%r' % (key, value)
9790 
      for key, value in self.__dict__.iteritems()]
9791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9792 
 
9793 
  def __eq__(self, other):
9794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9795 
 
9796 
  def __ne__(self, other):
9797 
    return not (self == other)
9798 
 
3064 chandransh 9799 
class getLineItemsForOrder_result:
94 ashish 9800 
  """
9801 
  Attributes:
9802 
   - success
9803 
   - ex
9804 
  """
9805 
 
9806 
  thrift_spec = (
3064 chandransh 9807 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9809 
  )
9810 
 
9811 
  def __init__(self, success=None, ex=None,):
9812 
    self.success = success
9813 
    self.ex = ex
9814 
 
9815 
  def read(self, iprot):
9816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9818 
      return
9819 
    iprot.readStructBegin()
9820 
    while True:
9821 
      (fname, ftype, fid) = iprot.readFieldBegin()
9822 
      if ftype == TType.STOP:
9823 
        break
9824 
      if fid == 0:
483 rajveer 9825 
        if ftype == TType.LIST:
9826 
          self.success = []
5031 varun.gupt 9827 
          (_etype164, _size161) = iprot.readListBegin()
9828 
          for _i165 in xrange(_size161):
9829 
            _elem166 = LineItem()
9830 
            _elem166.read(iprot)
9831 
            self.success.append(_elem166)
483 rajveer 9832 
          iprot.readListEnd()
94 ashish 9833 
        else:
9834 
          iprot.skip(ftype)
9835 
      elif fid == 1:
9836 
        if ftype == TType.STRUCT:
9837 
          self.ex = TransactionServiceException()
9838 
          self.ex.read(iprot)
9839 
        else:
9840 
          iprot.skip(ftype)
9841 
      else:
9842 
        iprot.skip(ftype)
9843 
      iprot.readFieldEnd()
9844 
    iprot.readStructEnd()
9845 
 
9846 
  def write(self, oprot):
9847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9849 
      return
3064 chandransh 9850 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9851 
    if self.success is not None:
483 rajveer 9852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9854 
      for iter167 in self.success:
9855 
        iter167.write(oprot)
483 rajveer 9856 
      oprot.writeListEnd()
94 ashish 9857 
      oprot.writeFieldEnd()
3431 rajveer 9858 
    if self.ex is not None:
94 ashish 9859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9860 
      self.ex.write(oprot)
9861 
      oprot.writeFieldEnd()
9862 
    oprot.writeFieldStop()
9863 
    oprot.writeStructEnd()
9864 
 
3431 rajveer 9865 
  def validate(self):
9866 
    return
9867 
 
9868 
 
94 ashish 9869 
  def __repr__(self):
9870 
    L = ['%s=%r' % (key, value)
9871 
      for key, value in self.__dict__.iteritems()]
9872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9873 
 
9874 
  def __eq__(self, other):
9875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9876 
 
9877 
  def __ne__(self, other):
9878 
    return not (self == other)
9879 
 
4999 phani.kuma 9880 
class getOrderList_args:
9881 
  """
9882 
  Attributes:
9883 
   - order_ids
9884 
  """
9885 
 
9886 
  thrift_spec = (
9887 
    None, # 0
9888 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9889 
  )
9890 
 
9891 
  def __init__(self, order_ids=None,):
9892 
    self.order_ids = order_ids
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      if fid == 1:
9904 
        if ftype == TType.LIST:
9905 
          self.order_ids = []
5031 varun.gupt 9906 
          (_etype171, _size168) = iprot.readListBegin()
9907 
          for _i172 in xrange(_size168):
9908 
            _elem173 = iprot.readI64();
9909 
            self.order_ids.append(_elem173)
4999 phani.kuma 9910 
          iprot.readListEnd()
9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      else:
9914 
        iprot.skip(ftype)
9915 
      iprot.readFieldEnd()
9916 
    iprot.readStructEnd()
9917 
 
9918 
  def write(self, oprot):
9919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9921 
      return
9922 
    oprot.writeStructBegin('getOrderList_args')
9923 
    if self.order_ids is not None:
9924 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9925 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9926 
      for iter174 in self.order_ids:
9927 
        oprot.writeI64(iter174)
4999 phani.kuma 9928 
      oprot.writeListEnd()
9929 
      oprot.writeFieldEnd()
9930 
    oprot.writeFieldStop()
9931 
    oprot.writeStructEnd()
9932 
 
9933 
  def validate(self):
9934 
    return
9935 
 
9936 
 
9937 
  def __repr__(self):
9938 
    L = ['%s=%r' % (key, value)
9939 
      for key, value in self.__dict__.iteritems()]
9940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9941 
 
9942 
  def __eq__(self, other):
9943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9944 
 
9945 
  def __ne__(self, other):
9946 
    return not (self == other)
9947 
 
9948 
class getOrderList_result:
9949 
  """
9950 
  Attributes:
9951 
   - success
9952 
  """
9953 
 
9954 
  thrift_spec = (
9955 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9956 
  )
9957 
 
9958 
  def __init__(self, success=None,):
9959 
    self.success = success
9960 
 
9961 
  def read(self, iprot):
9962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9964 
      return
9965 
    iprot.readStructBegin()
9966 
    while True:
9967 
      (fname, ftype, fid) = iprot.readFieldBegin()
9968 
      if ftype == TType.STOP:
9969 
        break
9970 
      if fid == 0:
9971 
        if ftype == TType.LIST:
9972 
          self.success = []
5031 varun.gupt 9973 
          (_etype178, _size175) = iprot.readListBegin()
9974 
          for _i179 in xrange(_size175):
9975 
            _elem180 = Order()
9976 
            _elem180.read(iprot)
9977 
            self.success.append(_elem180)
4999 phani.kuma 9978 
          iprot.readListEnd()
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      else:
9982 
        iprot.skip(ftype)
9983 
      iprot.readFieldEnd()
9984 
    iprot.readStructEnd()
9985 
 
9986 
  def write(self, oprot):
9987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9989 
      return
9990 
    oprot.writeStructBegin('getOrderList_result')
9991 
    if self.success is not None:
9992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9993 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9994 
      for iter181 in self.success:
9995 
        iter181.write(oprot)
4999 phani.kuma 9996 
      oprot.writeListEnd()
9997 
      oprot.writeFieldEnd()
9998 
    oprot.writeFieldStop()
9999 
    oprot.writeStructEnd()
10000 
 
10001 
  def validate(self):
10002 
    return
10003 
 
10004 
 
10005 
  def __repr__(self):
10006 
    L = ['%s=%r' % (key, value)
10007 
      for key, value in self.__dict__.iteritems()]
10008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10009 
 
10010 
  def __eq__(self, other):
10011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10012 
 
10013 
  def __ne__(self, other):
10014 
    return not (self == other)
10015 
 
5386 phani.kuma 10016 
class getOrderListForVendor_args:
10017 
  """
10018 
  Attributes:
10019 
   - order_ids
10020 
   - vendorId
10021 
  """
10022 
 
10023 
  thrift_spec = (
10024 
    None, # 0
10025 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10026 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10027 
  )
10028 
 
10029 
  def __init__(self, order_ids=None, vendorId=None,):
10030 
    self.order_ids = order_ids
10031 
    self.vendorId = vendorId
10032 
 
10033 
  def read(self, iprot):
10034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10036 
      return
10037 
    iprot.readStructBegin()
10038 
    while True:
10039 
      (fname, ftype, fid) = iprot.readFieldBegin()
10040 
      if ftype == TType.STOP:
10041 
        break
10042 
      if fid == 1:
10043 
        if ftype == TType.LIST:
10044 
          self.order_ids = []
10045 
          (_etype185, _size182) = iprot.readListBegin()
10046 
          for _i186 in xrange(_size182):
10047 
            _elem187 = iprot.readI64();
10048 
            self.order_ids.append(_elem187)
10049 
          iprot.readListEnd()
10050 
        else:
10051 
          iprot.skip(ftype)
10052 
      elif fid == 2:
10053 
        if ftype == TType.I64:
10054 
          self.vendorId = iprot.readI64();
10055 
        else:
10056 
          iprot.skip(ftype)
10057 
      else:
10058 
        iprot.skip(ftype)
10059 
      iprot.readFieldEnd()
10060 
    iprot.readStructEnd()
10061 
 
10062 
  def write(self, oprot):
10063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10065 
      return
10066 
    oprot.writeStructBegin('getOrderListForVendor_args')
10067 
    if self.order_ids is not None:
10068 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10069 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10070 
      for iter188 in self.order_ids:
10071 
        oprot.writeI64(iter188)
10072 
      oprot.writeListEnd()
10073 
      oprot.writeFieldEnd()
10074 
    if self.vendorId is not None:
10075 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10076 
      oprot.writeI64(self.vendorId)
10077 
      oprot.writeFieldEnd()
10078 
    oprot.writeFieldStop()
10079 
    oprot.writeStructEnd()
10080 
 
10081 
  def validate(self):
10082 
    return
10083 
 
10084 
 
10085 
  def __repr__(self):
10086 
    L = ['%s=%r' % (key, value)
10087 
      for key, value in self.__dict__.iteritems()]
10088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10089 
 
10090 
  def __eq__(self, other):
10091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10092 
 
10093 
  def __ne__(self, other):
10094 
    return not (self == other)
10095 
 
10096 
class getOrderListForVendor_result:
10097 
  """
10098 
  Attributes:
10099 
   - success
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10104 
  )
10105 
 
10106 
  def __init__(self, success=None,):
10107 
    self.success = success
10108 
 
10109 
  def read(self, iprot):
10110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10112 
      return
10113 
    iprot.readStructBegin()
10114 
    while True:
10115 
      (fname, ftype, fid) = iprot.readFieldBegin()
10116 
      if ftype == TType.STOP:
10117 
        break
10118 
      if fid == 0:
10119 
        if ftype == TType.LIST:
10120 
          self.success = []
10121 
          (_etype192, _size189) = iprot.readListBegin()
10122 
          for _i193 in xrange(_size189):
10123 
            _elem194 = Order()
10124 
            _elem194.read(iprot)
10125 
            self.success.append(_elem194)
10126 
          iprot.readListEnd()
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getOrderListForVendor_result')
10139 
    if self.success is not None:
10140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10142 
      for iter195 in self.success:
10143 
        iter195.write(oprot)
10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
3064 chandransh 10164 
class getOrderForCustomer_args:
94 ashish 10165 
  """
10166 
  Attributes:
3064 chandransh 10167 
   - orderId
483 rajveer 10168 
   - customerId
94 ashish 10169 
  """
10170 
 
10171 
  thrift_spec = (
10172 
    None, # 0
3064 chandransh 10173 
    (1, TType.I64, 'orderId', None, None, ), # 1
10174 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10175 
  )
10176 
 
3064 chandransh 10177 
  def __init__(self, orderId=None, customerId=None,):
10178 
    self.orderId = orderId
483 rajveer 10179 
    self.customerId = customerId
94 ashish 10180 
 
10181 
  def read(self, iprot):
10182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10184 
      return
10185 
    iprot.readStructBegin()
10186 
    while True:
10187 
      (fname, ftype, fid) = iprot.readFieldBegin()
10188 
      if ftype == TType.STOP:
10189 
        break
10190 
      if fid == 1:
10191 
        if ftype == TType.I64:
3064 chandransh 10192 
          self.orderId = iprot.readI64();
94 ashish 10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      elif fid == 2:
10196 
        if ftype == TType.I64:
3064 chandransh 10197 
          self.customerId = iprot.readI64();
94 ashish 10198 
        else:
10199 
          iprot.skip(ftype)
10200 
      else:
10201 
        iprot.skip(ftype)
10202 
      iprot.readFieldEnd()
10203 
    iprot.readStructEnd()
10204 
 
10205 
  def write(self, oprot):
10206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10208 
      return
3064 chandransh 10209 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10210 
    if self.orderId is not None:
3064 chandransh 10211 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10212 
      oprot.writeI64(self.orderId)
10213 
      oprot.writeFieldEnd()
3431 rajveer 10214 
    if self.customerId is not None:
3064 chandransh 10215 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10216 
      oprot.writeI64(self.customerId)
94 ashish 10217 
      oprot.writeFieldEnd()
10218 
    oprot.writeFieldStop()
10219 
    oprot.writeStructEnd()
10220 
 
3431 rajveer 10221 
  def validate(self):
10222 
    return
10223 
 
10224 
 
94 ashish 10225 
  def __repr__(self):
10226 
    L = ['%s=%r' % (key, value)
10227 
      for key, value in self.__dict__.iteritems()]
10228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10229 
 
10230 
  def __eq__(self, other):
10231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10232 
 
10233 
  def __ne__(self, other):
10234 
    return not (self == other)
10235 
 
3064 chandransh 10236 
class getOrderForCustomer_result:
94 ashish 10237 
  """
10238 
  Attributes:
10239 
   - success
10240 
   - ex
10241 
  """
10242 
 
10243 
  thrift_spec = (
3064 chandransh 10244 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10246 
  )
10247 
 
10248 
  def __init__(self, success=None, ex=None,):
10249 
    self.success = success
10250 
    self.ex = ex
10251 
 
10252 
  def read(self, iprot):
10253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10255 
      return
10256 
    iprot.readStructBegin()
10257 
    while True:
10258 
      (fname, ftype, fid) = iprot.readFieldBegin()
10259 
      if ftype == TType.STOP:
10260 
        break
10261 
      if fid == 0:
3064 chandransh 10262 
        if ftype == TType.STRUCT:
10263 
          self.success = Order()
10264 
          self.success.read(iprot)
94 ashish 10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      elif fid == 1:
10268 
        if ftype == TType.STRUCT:
10269 
          self.ex = TransactionServiceException()
10270 
          self.ex.read(iprot)
10271 
        else:
10272 
          iprot.skip(ftype)
10273 
      else:
10274 
        iprot.skip(ftype)
10275 
      iprot.readFieldEnd()
10276 
    iprot.readStructEnd()
10277 
 
10278 
  def write(self, oprot):
10279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10281 
      return
3064 chandransh 10282 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10283 
    if self.success is not None:
3064 chandransh 10284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10285 
      self.success.write(oprot)
94 ashish 10286 
      oprot.writeFieldEnd()
3431 rajveer 10287 
    if self.ex is not None:
94 ashish 10288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10289 
      self.ex.write(oprot)
10290 
      oprot.writeFieldEnd()
10291 
    oprot.writeFieldStop()
10292 
    oprot.writeStructEnd()
10293 
 
3431 rajveer 10294 
  def validate(self):
10295 
    return
10296 
 
10297 
 
94 ashish 10298 
  def __repr__(self):
10299 
    L = ['%s=%r' % (key, value)
10300 
      for key, value in self.__dict__.iteritems()]
10301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10302 
 
10303 
  def __eq__(self, other):
10304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10305 
 
10306 
  def __ne__(self, other):
10307 
    return not (self == other)
10308 
 
3064 chandransh 10309 
class getAlerts_args:
94 ashish 10310 
  """
10311 
  Attributes:
4394 rajveer 10312 
   - type
4444 rajveer 10313 
   - warehouseId
4394 rajveer 10314 
   - status
10315 
   - timestamp
94 ashish 10316 
  """
10317 
 
10318 
  thrift_spec = (
10319 
    None, # 0
4394 rajveer 10320 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10321 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10322 
    (3, TType.I64, 'status', None, None, ), # 3
10323 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10324 
  )
10325 
 
4444 rajveer 10326 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10327 
    self.type = type
4444 rajveer 10328 
    self.warehouseId = warehouseId
4394 rajveer 10329 
    self.status = status
10330 
    self.timestamp = timestamp
94 ashish 10331 
 
10332 
  def read(self, iprot):
10333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10335 
      return
10336 
    iprot.readStructBegin()
10337 
    while True:
10338 
      (fname, ftype, fid) = iprot.readFieldBegin()
10339 
      if ftype == TType.STOP:
10340 
        break
10341 
      if fid == 1:
3064 chandransh 10342 
        if ftype == TType.I64:
4394 rajveer 10343 
          self.type = iprot.readI64();
94 ashish 10344 
        else:
10345 
          iprot.skip(ftype)
3064 chandransh 10346 
      elif fid == 2:
4394 rajveer 10347 
        if ftype == TType.I64:
4444 rajveer 10348 
          self.warehouseId = iprot.readI64();
3064 chandransh 10349 
        else:
10350 
          iprot.skip(ftype)
4394 rajveer 10351 
      elif fid == 3:
10352 
        if ftype == TType.I64:
4444 rajveer 10353 
          self.status = iprot.readI64();
10354 
        else:
10355 
          iprot.skip(ftype)
10356 
      elif fid == 4:
10357 
        if ftype == TType.I64:
4394 rajveer 10358 
          self.timestamp = iprot.readI64();
10359 
        else:
10360 
          iprot.skip(ftype)
94 ashish 10361 
      else:
10362 
        iprot.skip(ftype)
10363 
      iprot.readFieldEnd()
10364 
    iprot.readStructEnd()
10365 
 
10366 
  def write(self, oprot):
10367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10369 
      return
3064 chandransh 10370 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10371 
    if self.type is not None:
10372 
      oprot.writeFieldBegin('type', TType.I64, 1)
10373 
      oprot.writeI64(self.type)
94 ashish 10374 
      oprot.writeFieldEnd()
4444 rajveer 10375 
    if self.warehouseId is not None:
10376 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10377 
      oprot.writeI64(self.warehouseId)
10378 
      oprot.writeFieldEnd()
4394 rajveer 10379 
    if self.status is not None:
4444 rajveer 10380 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10381 
      oprot.writeI64(self.status)
3064 chandransh 10382 
      oprot.writeFieldEnd()
4394 rajveer 10383 
    if self.timestamp is not None:
4444 rajveer 10384 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10385 
      oprot.writeI64(self.timestamp)
10386 
      oprot.writeFieldEnd()
94 ashish 10387 
    oprot.writeFieldStop()
10388 
    oprot.writeStructEnd()
10389 
 
3431 rajveer 10390 
  def validate(self):
10391 
    return
10392 
 
10393 
 
94 ashish 10394 
  def __repr__(self):
10395 
    L = ['%s=%r' % (key, value)
10396 
      for key, value in self.__dict__.iteritems()]
10397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10398 
 
10399 
  def __eq__(self, other):
10400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10401 
 
10402 
  def __ne__(self, other):
10403 
    return not (self == other)
10404 
 
3064 chandransh 10405 
class getAlerts_result:
94 ashish 10406 
  """
10407 
  Attributes:
10408 
   - success
10409 
  """
10410 
 
10411 
  thrift_spec = (
3064 chandransh 10412 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10413 
  )
10414 
 
3064 chandransh 10415 
  def __init__(self, success=None,):
94 ashish 10416 
    self.success = success
10417 
 
10418 
  def read(self, iprot):
10419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10421 
      return
10422 
    iprot.readStructBegin()
10423 
    while True:
10424 
      (fname, ftype, fid) = iprot.readFieldBegin()
10425 
      if ftype == TType.STOP:
10426 
        break
10427 
      if fid == 0:
3064 chandransh 10428 
        if ftype == TType.LIST:
10429 
          self.success = []
5386 phani.kuma 10430 
          (_etype199, _size196) = iprot.readListBegin()
10431 
          for _i200 in xrange(_size196):
10432 
            _elem201 = Alert()
10433 
            _elem201.read(iprot)
10434 
            self.success.append(_elem201)
3064 chandransh 10435 
          iprot.readListEnd()
94 ashish 10436 
        else:
10437 
          iprot.skip(ftype)
10438 
      else:
10439 
        iprot.skip(ftype)
10440 
      iprot.readFieldEnd()
10441 
    iprot.readStructEnd()
10442 
 
10443 
  def write(self, oprot):
10444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10446 
      return
3064 chandransh 10447 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10448 
    if self.success is not None:
3064 chandransh 10449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10451 
      for iter202 in self.success:
10452 
        iter202.write(oprot)
3064 chandransh 10453 
      oprot.writeListEnd()
94 ashish 10454 
      oprot.writeFieldEnd()
10455 
    oprot.writeFieldStop()
10456 
    oprot.writeStructEnd()
10457 
 
3431 rajveer 10458 
  def validate(self):
10459 
    return
10460 
 
10461 
 
94 ashish 10462 
  def __repr__(self):
10463 
    L = ['%s=%r' % (key, value)
10464 
      for key, value in self.__dict__.iteritems()]
10465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10466 
 
10467 
  def __eq__(self, other):
10468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10469 
 
10470 
  def __ne__(self, other):
10471 
    return not (self == other)
10472 
 
4394 rajveer 10473 
class addAlert_args:
94 ashish 10474 
  """
10475 
  Attributes:
3064 chandransh 10476 
   - type
4444 rajveer 10477 
   - warehouseId
4394 rajveer 10478 
   - description
94 ashish 10479 
  """
10480 
 
10481 
  thrift_spec = (
10482 
    None, # 0
4394 rajveer 10483 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10484 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10485 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10486 
  )
10487 
 
4444 rajveer 10488 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10489 
    self.type = type
4444 rajveer 10490 
    self.warehouseId = warehouseId
4394 rajveer 10491 
    self.description = description
94 ashish 10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 1:
10503 
        if ftype == TType.I64:
4394 rajveer 10504 
          self.type = iprot.readI64();
94 ashish 10505 
        else:
10506 
          iprot.skip(ftype)
3064 chandransh 10507 
      elif fid == 2:
4444 rajveer 10508 
        if ftype == TType.I64:
10509 
          self.warehouseId = iprot.readI64();
10510 
        else:
10511 
          iprot.skip(ftype)
10512 
      elif fid == 3:
3064 chandransh 10513 
        if ftype == TType.STRING:
4394 rajveer 10514 
          self.description = iprot.readString();
3064 chandransh 10515 
        else:
10516 
          iprot.skip(ftype)
94 ashish 10517 
      else:
10518 
        iprot.skip(ftype)
10519 
      iprot.readFieldEnd()
10520 
    iprot.readStructEnd()
10521 
 
10522 
  def write(self, oprot):
10523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10525 
      return
4394 rajveer 10526 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10527 
    if self.type is not None:
4394 rajveer 10528 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10529 
      oprot.writeI64(self.type)
10530 
      oprot.writeFieldEnd()
4444 rajveer 10531 
    if self.warehouseId is not None:
10532 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10533 
      oprot.writeI64(self.warehouseId)
10534 
      oprot.writeFieldEnd()
4394 rajveer 10535 
    if self.description is not None:
4444 rajveer 10536 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10537 
      oprot.writeString(self.description)
3064 chandransh 10538 
      oprot.writeFieldEnd()
94 ashish 10539 
    oprot.writeFieldStop()
10540 
    oprot.writeStructEnd()
10541 
 
3431 rajveer 10542 
  def validate(self):
10543 
    return
10544 
 
10545 
 
94 ashish 10546 
  def __repr__(self):
10547 
    L = ['%s=%r' % (key, value)
10548 
      for key, value in self.__dict__.iteritems()]
10549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10550 
 
10551 
  def __eq__(self, other):
10552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10553 
 
10554 
  def __ne__(self, other):
10555 
    return not (self == other)
10556 
 
4394 rajveer 10557 
class addAlert_result:
3064 chandransh 10558 
 
10559 
  thrift_spec = (
10560 
  )
10561 
 
10562 
  def read(self, iprot):
10563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10565 
      return
10566 
    iprot.readStructBegin()
10567 
    while True:
10568 
      (fname, ftype, fid) = iprot.readFieldBegin()
10569 
      if ftype == TType.STOP:
10570 
        break
10571 
      else:
10572 
        iprot.skip(ftype)
10573 
      iprot.readFieldEnd()
10574 
    iprot.readStructEnd()
10575 
 
10576 
  def write(self, oprot):
10577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10579 
      return
4394 rajveer 10580 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10581 
    oprot.writeFieldStop()
10582 
    oprot.writeStructEnd()
10583 
 
3431 rajveer 10584 
  def validate(self):
10585 
    return
10586 
 
10587 
 
3064 chandransh 10588 
  def __repr__(self):
10589 
    L = ['%s=%r' % (key, value)
10590 
      for key, value in self.__dict__.iteritems()]
10591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10592 
 
10593 
  def __eq__(self, other):
10594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10595 
 
10596 
  def __ne__(self, other):
10597 
    return not (self == other)
10598 
 
4444 rajveer 10599 
class markAlertsAsSeen_args:
10600 
  """
10601 
  Attributes:
10602 
   - warehouseId
10603 
  """
10604 
 
10605 
  thrift_spec = (
10606 
    None, # 0
10607 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10608 
  )
10609 
 
10610 
  def __init__(self, warehouseId=None,):
10611 
    self.warehouseId = warehouseId
10612 
 
10613 
  def read(self, iprot):
10614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10616 
      return
10617 
    iprot.readStructBegin()
10618 
    while True:
10619 
      (fname, ftype, fid) = iprot.readFieldBegin()
10620 
      if ftype == TType.STOP:
10621 
        break
10622 
      if fid == 1:
10623 
        if ftype == TType.I64:
10624 
          self.warehouseId = iprot.readI64();
10625 
        else:
10626 
          iprot.skip(ftype)
10627 
      else:
10628 
        iprot.skip(ftype)
10629 
      iprot.readFieldEnd()
10630 
    iprot.readStructEnd()
10631 
 
10632 
  def write(self, oprot):
10633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10635 
      return
10636 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10637 
    if self.warehouseId is not None:
10638 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10639 
      oprot.writeI64(self.warehouseId)
10640 
      oprot.writeFieldEnd()
10641 
    oprot.writeFieldStop()
10642 
    oprot.writeStructEnd()
10643 
 
10644 
  def validate(self):
10645 
    return
10646 
 
10647 
 
10648 
  def __repr__(self):
10649 
    L = ['%s=%r' % (key, value)
10650 
      for key, value in self.__dict__.iteritems()]
10651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10652 
 
10653 
  def __eq__(self, other):
10654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10655 
 
10656 
  def __ne__(self, other):
10657 
    return not (self == other)
10658 
 
10659 
class markAlertsAsSeen_result:
10660 
 
10661 
  thrift_spec = (
10662 
  )
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      else:
10674 
        iprot.skip(ftype)
10675 
      iprot.readFieldEnd()
10676 
    iprot.readStructEnd()
10677 
 
10678 
  def write(self, oprot):
10679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10681 
      return
10682 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10683 
    oprot.writeFieldStop()
10684 
    oprot.writeStructEnd()
10685 
 
10686 
  def validate(self):
10687 
    return
10688 
 
10689 
 
10690 
  def __repr__(self):
10691 
    L = ['%s=%r' % (key, value)
10692 
      for key, value in self.__dict__.iteritems()]
10693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10694 
 
10695 
  def __eq__(self, other):
10696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10697 
 
10698 
  def __ne__(self, other):
10699 
    return not (self == other)
10700 
 
3064 chandransh 10701 
class getValidOrderCount_args:
10702 
 
10703 
  thrift_spec = (
10704 
  )
10705 
 
10706 
  def read(self, iprot):
10707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10709 
      return
10710 
    iprot.readStructBegin()
10711 
    while True:
10712 
      (fname, ftype, fid) = iprot.readFieldBegin()
10713 
      if ftype == TType.STOP:
10714 
        break
10715 
      else:
10716 
        iprot.skip(ftype)
10717 
      iprot.readFieldEnd()
10718 
    iprot.readStructEnd()
10719 
 
10720 
  def write(self, oprot):
10721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10723 
      return
10724 
    oprot.writeStructBegin('getValidOrderCount_args')
10725 
    oprot.writeFieldStop()
10726 
    oprot.writeStructEnd()
10727 
 
3431 rajveer 10728 
  def validate(self):
10729 
    return
10730 
 
10731 
 
3064 chandransh 10732 
  def __repr__(self):
10733 
    L = ['%s=%r' % (key, value)
10734 
      for key, value in self.__dict__.iteritems()]
10735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10736 
 
10737 
  def __eq__(self, other):
10738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10739 
 
10740 
  def __ne__(self, other):
10741 
    return not (self == other)
10742 
 
10743 
class getValidOrderCount_result:
94 ashish 10744 
  """
10745 
  Attributes:
10746 
   - success
10747 
  """
10748 
 
10749 
  thrift_spec = (
3064 chandransh 10750 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10751 
  )
10752 
 
3064 chandransh 10753 
  def __init__(self, success=None,):
94 ashish 10754 
    self.success = success
10755 
 
10756 
  def read(self, iprot):
10757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10759 
      return
10760 
    iprot.readStructBegin()
10761 
    while True:
10762 
      (fname, ftype, fid) = iprot.readFieldBegin()
10763 
      if ftype == TType.STOP:
10764 
        break
10765 
      if fid == 0:
3064 chandransh 10766 
        if ftype == TType.I64:
10767 
          self.success = iprot.readI64();
94 ashish 10768 
        else:
10769 
          iprot.skip(ftype)
10770 
      else:
10771 
        iprot.skip(ftype)
10772 
      iprot.readFieldEnd()
10773 
    iprot.readStructEnd()
10774 
 
10775 
  def write(self, oprot):
10776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10778 
      return
3064 chandransh 10779 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10780 
    if self.success is not None:
3064 chandransh 10781 
      oprot.writeFieldBegin('success', TType.I64, 0)
10782 
      oprot.writeI64(self.success)
94 ashish 10783 
      oprot.writeFieldEnd()
10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
3431 rajveer 10787 
  def validate(self):
10788 
    return
10789 
 
10790 
 
94 ashish 10791 
  def __repr__(self):
10792 
    L = ['%s=%r' % (key, value)
10793 
      for key, value in self.__dict__.iteritems()]
10794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10795 
 
10796 
  def __eq__(self, other):
10797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10798 
 
10799 
  def __ne__(self, other):
10800 
    return not (self == other)
10801 
 
3064 chandransh 10802 
class getNoOfCustomersWithSuccessfulTransaction_args:
10803 
 
10804 
  thrift_spec = (
10805 
  )
10806 
 
10807 
  def read(self, iprot):
10808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10810 
      return
10811 
    iprot.readStructBegin()
10812 
    while True:
10813 
      (fname, ftype, fid) = iprot.readFieldBegin()
10814 
      if ftype == TType.STOP:
10815 
        break
10816 
      else:
10817 
        iprot.skip(ftype)
10818 
      iprot.readFieldEnd()
10819 
    iprot.readStructEnd()
10820 
 
10821 
  def write(self, oprot):
10822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10824 
      return
10825 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
3431 rajveer 10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
3064 chandransh 10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
10844 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10845 
  """
10846 
  Attributes:
3064 chandransh 10847 
   - success
94 ashish 10848 
  """
10849 
 
10850 
  thrift_spec = (
3064 chandransh 10851 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10852 
  )
10853 
 
3064 chandransh 10854 
  def __init__(self, success=None,):
10855 
    self.success = success
94 ashish 10856 
 
10857 
  def read(self, iprot):
10858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10860 
      return
10861 
    iprot.readStructBegin()
10862 
    while True:
10863 
      (fname, ftype, fid) = iprot.readFieldBegin()
10864 
      if ftype == TType.STOP:
10865 
        break
3064 chandransh 10866 
      if fid == 0:
94 ashish 10867 
        if ftype == TType.I64:
3064 chandransh 10868 
          self.success = iprot.readI64();
94 ashish 10869 
        else:
10870 
          iprot.skip(ftype)
10871 
      else:
10872 
        iprot.skip(ftype)
10873 
      iprot.readFieldEnd()
10874 
    iprot.readStructEnd()
10875 
 
10876 
  def write(self, oprot):
10877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10879 
      return
3064 chandransh 10880 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10881 
    if self.success is not None:
3064 chandransh 10882 
      oprot.writeFieldBegin('success', TType.I64, 0)
10883 
      oprot.writeI64(self.success)
94 ashish 10884 
      oprot.writeFieldEnd()
10885 
    oprot.writeFieldStop()
10886 
    oprot.writeStructEnd()
10887 
 
3431 rajveer 10888 
  def validate(self):
10889 
    return
10890 
 
10891 
 
94 ashish 10892 
  def __repr__(self):
10893 
    L = ['%s=%r' % (key, value)
10894 
      for key, value in self.__dict__.iteritems()]
10895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10896 
 
10897 
  def __eq__(self, other):
10898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10899 
 
10900 
  def __ne__(self, other):
10901 
    return not (self == other)
10902 
 
3064 chandransh 10903 
class getValidOrdersAmountRange_args:
10904 
 
10905 
  thrift_spec = (
10906 
  )
10907 
 
10908 
  def read(self, iprot):
10909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10911 
      return
10912 
    iprot.readStructBegin()
10913 
    while True:
10914 
      (fname, ftype, fid) = iprot.readFieldBegin()
10915 
      if ftype == TType.STOP:
10916 
        break
10917 
      else:
10918 
        iprot.skip(ftype)
10919 
      iprot.readFieldEnd()
10920 
    iprot.readStructEnd()
10921 
 
10922 
  def write(self, oprot):
10923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10925 
      return
10926 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10927 
    oprot.writeFieldStop()
10928 
    oprot.writeStructEnd()
10929 
 
3431 rajveer 10930 
  def validate(self):
10931 
    return
10932 
 
10933 
 
3064 chandransh 10934 
  def __repr__(self):
10935 
    L = ['%s=%r' % (key, value)
10936 
      for key, value in self.__dict__.iteritems()]
10937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10938 
 
10939 
  def __eq__(self, other):
10940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10941 
 
10942 
  def __ne__(self, other):
10943 
    return not (self == other)
10944 
 
10945 
class getValidOrdersAmountRange_result:
94 ashish 10946 
  """
10947 
  Attributes:
10948 
   - success
10949 
  """
10950 
 
10951 
  thrift_spec = (
3064 chandransh 10952 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10953 
  )
10954 
 
3064 chandransh 10955 
  def __init__(self, success=None,):
94 ashish 10956 
    self.success = success
10957 
 
10958 
  def read(self, iprot):
10959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10961 
      return
10962 
    iprot.readStructBegin()
10963 
    while True:
10964 
      (fname, ftype, fid) = iprot.readFieldBegin()
10965 
      if ftype == TType.STOP:
10966 
        break
10967 
      if fid == 0:
483 rajveer 10968 
        if ftype == TType.LIST:
10969 
          self.success = []
5386 phani.kuma 10970 
          (_etype206, _size203) = iprot.readListBegin()
10971 
          for _i207 in xrange(_size203):
10972 
            _elem208 = iprot.readDouble();
10973 
            self.success.append(_elem208)
483 rajveer 10974 
          iprot.readListEnd()
94 ashish 10975 
        else:
10976 
          iprot.skip(ftype)
10977 
      else:
10978 
        iprot.skip(ftype)
10979 
      iprot.readFieldEnd()
10980 
    iprot.readStructEnd()
10981 
 
10982 
  def write(self, oprot):
10983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10985 
      return
3064 chandransh 10986 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10987 
    if self.success is not None:
483 rajveer 10988 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10989 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 10990 
      for iter209 in self.success:
10991 
        oprot.writeDouble(iter209)
483 rajveer 10992 
      oprot.writeListEnd()
94 ashish 10993 
      oprot.writeFieldEnd()
10994 
    oprot.writeFieldStop()
10995 
    oprot.writeStructEnd()
10996 
 
3431 rajveer 10997 
  def validate(self):
10998 
    return
10999 
 
11000 
 
94 ashish 11001 
  def __repr__(self):
11002 
    L = ['%s=%r' % (key, value)
11003 
      for key, value in self.__dict__.iteritems()]
11004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11005 
 
11006 
  def __eq__(self, other):
11007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11008 
 
11009 
  def __ne__(self, other):
11010 
    return not (self == other)
11011 
 
3064 chandransh 11012 
class getValidOrders_args:
1528 ankur.sing 11013 
  """
11014 
  Attributes:
3064 chandransh 11015 
   - limit
1528 ankur.sing 11016 
  """
11017 
 
11018 
  thrift_spec = (
11019 
    None, # 0
3064 chandransh 11020 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11021 
  )
11022 
 
3064 chandransh 11023 
  def __init__(self, limit=None,):
11024 
    self.limit = limit
1528 ankur.sing 11025 
 
11026 
  def read(self, iprot):
11027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11029 
      return
11030 
    iprot.readStructBegin()
11031 
    while True:
11032 
      (fname, ftype, fid) = iprot.readFieldBegin()
11033 
      if ftype == TType.STOP:
11034 
        break
11035 
      if fid == 1:
11036 
        if ftype == TType.I64:
3064 chandransh 11037 
          self.limit = iprot.readI64();
1528 ankur.sing 11038 
        else:
11039 
          iprot.skip(ftype)
11040 
      else:
11041 
        iprot.skip(ftype)
11042 
      iprot.readFieldEnd()
11043 
    iprot.readStructEnd()
11044 
 
11045 
  def write(self, oprot):
11046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11048 
      return
3064 chandransh 11049 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11050 
    if self.limit is not None:
3064 chandransh 11051 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11052 
      oprot.writeI64(self.limit)
1528 ankur.sing 11053 
      oprot.writeFieldEnd()
11054 
    oprot.writeFieldStop()
11055 
    oprot.writeStructEnd()
11056 
 
3431 rajveer 11057 
  def validate(self):
11058 
    return
11059 
 
11060 
 
1528 ankur.sing 11061 
  def __repr__(self):
11062 
    L = ['%s=%r' % (key, value)
11063 
      for key, value in self.__dict__.iteritems()]
11064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11065 
 
11066 
  def __eq__(self, other):
11067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11068 
 
11069 
  def __ne__(self, other):
11070 
    return not (self == other)
11071 
 
3064 chandransh 11072 
class getValidOrders_result:
1528 ankur.sing 11073 
  """
11074 
  Attributes:
11075 
   - success
11076 
  """
11077 
 
11078 
  thrift_spec = (
3064 chandransh 11079 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11080 
  )
11081 
 
3064 chandransh 11082 
  def __init__(self, success=None,):
1528 ankur.sing 11083 
    self.success = success
11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 0:
3064 chandransh 11095 
        if ftype == TType.LIST:
11096 
          self.success = []
5386 phani.kuma 11097 
          (_etype213, _size210) = iprot.readListBegin()
11098 
          for _i214 in xrange(_size210):
11099 
            _elem215 = Order()
11100 
            _elem215.read(iprot)
11101 
            self.success.append(_elem215)
3064 chandransh 11102 
          iprot.readListEnd()
1528 ankur.sing 11103 
        else:
11104 
          iprot.skip(ftype)
11105 
      else:
11106 
        iprot.skip(ftype)
11107 
      iprot.readFieldEnd()
11108 
    iprot.readStructEnd()
11109 
 
11110 
  def write(self, oprot):
11111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11113 
      return
3064 chandransh 11114 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11115 
    if self.success is not None:
3064 chandransh 11116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11118 
      for iter216 in self.success:
11119 
        iter216.write(oprot)
3064 chandransh 11120 
      oprot.writeListEnd()
1528 ankur.sing 11121 
      oprot.writeFieldEnd()
11122 
    oprot.writeFieldStop()
11123 
    oprot.writeStructEnd()
11124 
 
3431 rajveer 11125 
  def validate(self):
11126 
    return
11127 
 
11128 
 
1528 ankur.sing 11129 
  def __repr__(self):
11130 
    L = ['%s=%r' % (key, value)
11131 
      for key, value in self.__dict__.iteritems()]
11132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11133 
 
11134 
  def __eq__(self, other):
11135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11136 
 
11137 
  def __ne__(self, other):
11138 
    return not (self == other)
11139 
 
1220 chandransh 11140 
class batchOrders_args:
11141 
  """
11142 
  Attributes:
11143 
   - warehouseId
11144 
  """
11145 
 
11146 
  thrift_spec = (
11147 
    None, # 0
11148 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11149 
  )
11150 
 
11151 
  def __init__(self, warehouseId=None,):
11152 
    self.warehouseId = warehouseId
11153 
 
11154 
  def read(self, iprot):
11155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11157 
      return
11158 
    iprot.readStructBegin()
11159 
    while True:
11160 
      (fname, ftype, fid) = iprot.readFieldBegin()
11161 
      if ftype == TType.STOP:
11162 
        break
11163 
      if fid == 1:
11164 
        if ftype == TType.I64:
11165 
          self.warehouseId = iprot.readI64();
11166 
        else:
11167 
          iprot.skip(ftype)
11168 
      else:
11169 
        iprot.skip(ftype)
11170 
      iprot.readFieldEnd()
11171 
    iprot.readStructEnd()
11172 
 
11173 
  def write(self, oprot):
11174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11176 
      return
11177 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11178 
    if self.warehouseId is not None:
1220 chandransh 11179 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11180 
      oprot.writeI64(self.warehouseId)
11181 
      oprot.writeFieldEnd()
11182 
    oprot.writeFieldStop()
11183 
    oprot.writeStructEnd()
11184 
 
3431 rajveer 11185 
  def validate(self):
11186 
    return
11187 
 
11188 
 
1220 chandransh 11189 
  def __repr__(self):
11190 
    L = ['%s=%r' % (key, value)
11191 
      for key, value in self.__dict__.iteritems()]
11192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11193 
 
11194 
  def __eq__(self, other):
11195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11196 
 
11197 
  def __ne__(self, other):
11198 
    return not (self == other)
11199 
 
11200 
class batchOrders_result:
11201 
  """
11202 
  Attributes:
11203 
   - success
11204 
   - ex
11205 
  """
11206 
 
11207 
  thrift_spec = (
11208 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11210 
  )
11211 
 
11212 
  def __init__(self, success=None, ex=None,):
11213 
    self.success = success
11214 
    self.ex = ex
11215 
 
11216 
  def read(self, iprot):
11217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11219 
      return
11220 
    iprot.readStructBegin()
11221 
    while True:
11222 
      (fname, ftype, fid) = iprot.readFieldBegin()
11223 
      if ftype == TType.STOP:
11224 
        break
11225 
      if fid == 0:
11226 
        if ftype == TType.LIST:
11227 
          self.success = []
5386 phani.kuma 11228 
          (_etype220, _size217) = iprot.readListBegin()
11229 
          for _i221 in xrange(_size217):
11230 
            _elem222 = Order()
11231 
            _elem222.read(iprot)
11232 
            self.success.append(_elem222)
1220 chandransh 11233 
          iprot.readListEnd()
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      elif fid == 1:
11237 
        if ftype == TType.STRUCT:
11238 
          self.ex = TransactionServiceException()
11239 
          self.ex.read(iprot)
11240 
        else:
11241 
          iprot.skip(ftype)
11242 
      else:
11243 
        iprot.skip(ftype)
11244 
      iprot.readFieldEnd()
11245 
    iprot.readStructEnd()
11246 
 
11247 
  def write(self, oprot):
11248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11250 
      return
11251 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11252 
    if self.success is not None:
1220 chandransh 11253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11254 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11255 
      for iter223 in self.success:
11256 
        iter223.write(oprot)
1220 chandransh 11257 
      oprot.writeListEnd()
11258 
      oprot.writeFieldEnd()
3431 rajveer 11259 
    if self.ex is not None:
1220 chandransh 11260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11261 
      self.ex.write(oprot)
11262 
      oprot.writeFieldEnd()
11263 
    oprot.writeFieldStop()
11264 
    oprot.writeStructEnd()
11265 
 
3431 rajveer 11266 
  def validate(self):
11267 
    return
11268 
 
11269 
 
1220 chandransh 11270 
  def __repr__(self):
11271 
    L = ['%s=%r' % (key, value)
11272 
      for key, value in self.__dict__.iteritems()]
11273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11274 
 
11275 
  def __eq__(self, other):
11276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11277 
 
11278 
  def __ne__(self, other):
11279 
    return not (self == other)
11280 
 
1208 chandransh 11281 
class markOrderAsOutOfStock_args:
11282 
  """
11283 
  Attributes:
11284 
   - orderId
11285 
  """
11286 
 
11287 
  thrift_spec = (
11288 
    None, # 0
11289 
    (1, TType.I64, 'orderId', None, None, ), # 1
11290 
  )
11291 
 
11292 
  def __init__(self, orderId=None,):
11293 
    self.orderId = orderId
11294 
 
11295 
  def read(self, iprot):
11296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11298 
      return
11299 
    iprot.readStructBegin()
11300 
    while True:
11301 
      (fname, ftype, fid) = iprot.readFieldBegin()
11302 
      if ftype == TType.STOP:
11303 
        break
11304 
      if fid == 1:
11305 
        if ftype == TType.I64:
11306 
          self.orderId = iprot.readI64();
11307 
        else:
11308 
          iprot.skip(ftype)
11309 
      else:
11310 
        iprot.skip(ftype)
11311 
      iprot.readFieldEnd()
11312 
    iprot.readStructEnd()
11313 
 
11314 
  def write(self, oprot):
11315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11317 
      return
11318 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11319 
    if self.orderId is not None:
1208 chandransh 11320 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11321 
      oprot.writeI64(self.orderId)
11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
3431 rajveer 11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
1208 chandransh 11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
11341 
class markOrderAsOutOfStock_result:
11342 
  """
11343 
  Attributes:
11344 
   - success
11345 
   - ex
11346 
  """
11347 
 
11348 
  thrift_spec = (
11349 
    (0, TType.BOOL, 'success', None, None, ), # 0
11350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11351 
  )
11352 
 
11353 
  def __init__(self, success=None, ex=None,):
11354 
    self.success = success
11355 
    self.ex = ex
11356 
 
11357 
  def read(self, iprot):
11358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11360 
      return
11361 
    iprot.readStructBegin()
11362 
    while True:
11363 
      (fname, ftype, fid) = iprot.readFieldBegin()
11364 
      if ftype == TType.STOP:
11365 
        break
11366 
      if fid == 0:
11367 
        if ftype == TType.BOOL:
11368 
          self.success = iprot.readBool();
11369 
        else:
11370 
          iprot.skip(ftype)
11371 
      elif fid == 1:
11372 
        if ftype == TType.STRUCT:
11373 
          self.ex = TransactionServiceException()
11374 
          self.ex.read(iprot)
11375 
        else:
11376 
          iprot.skip(ftype)
11377 
      else:
11378 
        iprot.skip(ftype)
11379 
      iprot.readFieldEnd()
11380 
    iprot.readStructEnd()
11381 
 
11382 
  def write(self, oprot):
11383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11385 
      return
11386 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11387 
    if self.success is not None:
1208 chandransh 11388 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11389 
      oprot.writeBool(self.success)
11390 
      oprot.writeFieldEnd()
3431 rajveer 11391 
    if self.ex is not None:
1208 chandransh 11392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11393 
      self.ex.write(oprot)
11394 
      oprot.writeFieldEnd()
11395 
    oprot.writeFieldStop()
11396 
    oprot.writeStructEnd()
11397 
 
3431 rajveer 11398 
  def validate(self):
11399 
    return
11400 
 
11401 
 
1208 chandransh 11402 
  def __repr__(self):
11403 
    L = ['%s=%r' % (key, value)
11404 
      for key, value in self.__dict__.iteritems()]
11405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11406 
 
11407 
  def __eq__(self, other):
11408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11409 
 
11410 
  def __ne__(self, other):
11411 
    return not (self == other)
11412 
 
3064 chandransh 11413 
class verifyOrder_args:
759 chandransh 11414 
  """
11415 
  Attributes:
3064 chandransh 11416 
   - orderId
759 chandransh 11417 
  """
11418 
 
11419 
  thrift_spec = (
11420 
    None, # 0
3064 chandransh 11421 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11422 
  )
11423 
 
3064 chandransh 11424 
  def __init__(self, orderId=None,):
11425 
    self.orderId = orderId
759 chandransh 11426 
 
11427 
  def read(self, iprot):
11428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11430 
      return
11431 
    iprot.readStructBegin()
11432 
    while True:
11433 
      (fname, ftype, fid) = iprot.readFieldBegin()
11434 
      if ftype == TType.STOP:
11435 
        break
11436 
      if fid == 1:
11437 
        if ftype == TType.I64:
3064 chandransh 11438 
          self.orderId = iprot.readI64();
759 chandransh 11439 
        else:
11440 
          iprot.skip(ftype)
11441 
      else:
11442 
        iprot.skip(ftype)
11443 
      iprot.readFieldEnd()
11444 
    iprot.readStructEnd()
11445 
 
11446 
  def write(self, oprot):
11447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11449 
      return
3064 chandransh 11450 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11451 
    if self.orderId is not None:
3064 chandransh 11452 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11453 
      oprot.writeI64(self.orderId)
759 chandransh 11454 
      oprot.writeFieldEnd()
11455 
    oprot.writeFieldStop()
11456 
    oprot.writeStructEnd()
11457 
 
3431 rajveer 11458 
  def validate(self):
11459 
    return
11460 
 
11461 
 
759 chandransh 11462 
  def __repr__(self):
11463 
    L = ['%s=%r' % (key, value)
11464 
      for key, value in self.__dict__.iteritems()]
11465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11466 
 
11467 
  def __eq__(self, other):
11468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11469 
 
11470 
  def __ne__(self, other):
11471 
    return not (self == other)
11472 
 
3064 chandransh 11473 
class verifyOrder_result:
759 chandransh 11474 
  """
11475 
  Attributes:
11476 
   - success
11477 
   - ex
11478 
  """
11479 
 
11480 
  thrift_spec = (
11481 
    (0, TType.BOOL, 'success', None, None, ), # 0
11482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11483 
  )
11484 
 
11485 
  def __init__(self, success=None, ex=None,):
11486 
    self.success = success
11487 
    self.ex = ex
11488 
 
11489 
  def read(self, iprot):
11490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11492 
      return
11493 
    iprot.readStructBegin()
11494 
    while True:
11495 
      (fname, ftype, fid) = iprot.readFieldBegin()
11496 
      if ftype == TType.STOP:
11497 
        break
11498 
      if fid == 0:
11499 
        if ftype == TType.BOOL:
11500 
          self.success = iprot.readBool();
11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      elif fid == 1:
11504 
        if ftype == TType.STRUCT:
11505 
          self.ex = TransactionServiceException()
11506 
          self.ex.read(iprot)
11507 
        else:
11508 
          iprot.skip(ftype)
11509 
      else:
11510 
        iprot.skip(ftype)
11511 
      iprot.readFieldEnd()
11512 
    iprot.readStructEnd()
11513 
 
11514 
  def write(self, oprot):
11515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11517 
      return
3064 chandransh 11518 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11519 
    if self.success is not None:
759 chandransh 11520 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11521 
      oprot.writeBool(self.success)
11522 
      oprot.writeFieldEnd()
3431 rajveer 11523 
    if self.ex is not None:
759 chandransh 11524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11525 
      self.ex.write(oprot)
11526 
      oprot.writeFieldEnd()
11527 
    oprot.writeFieldStop()
11528 
    oprot.writeStructEnd()
11529 
 
3431 rajveer 11530 
  def validate(self):
11531 
    return
11532 
 
11533 
 
759 chandransh 11534 
  def __repr__(self):
11535 
    L = ['%s=%r' % (key, value)
11536 
      for key, value in self.__dict__.iteritems()]
11537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11538 
 
11539 
  def __eq__(self, other):
11540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11541 
 
11542 
  def __ne__(self, other):
11543 
    return not (self == other)
11544 
 
3064 chandransh 11545 
class acceptOrder_args:
1113 chandransh 11546 
  """
11547 
  Attributes:
3064 chandransh 11548 
   - orderId
1113 chandransh 11549 
  """
11550 
 
11551 
  thrift_spec = (
11552 
    None, # 0
3064 chandransh 11553 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11554 
  )
11555 
 
3064 chandransh 11556 
  def __init__(self, orderId=None,):
11557 
    self.orderId = orderId
1113 chandransh 11558 
 
11559 
  def read(self, iprot):
11560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11562 
      return
11563 
    iprot.readStructBegin()
11564 
    while True:
11565 
      (fname, ftype, fid) = iprot.readFieldBegin()
11566 
      if ftype == TType.STOP:
11567 
        break
11568 
      if fid == 1:
11569 
        if ftype == TType.I64:
3064 chandransh 11570 
          self.orderId = iprot.readI64();
1113 chandransh 11571 
        else:
11572 
          iprot.skip(ftype)
11573 
      else:
11574 
        iprot.skip(ftype)
11575 
      iprot.readFieldEnd()
11576 
    iprot.readStructEnd()
11577 
 
11578 
  def write(self, oprot):
11579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11581 
      return
3064 chandransh 11582 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11583 
    if self.orderId is not None:
3064 chandransh 11584 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11585 
      oprot.writeI64(self.orderId)
1113 chandransh 11586 
      oprot.writeFieldEnd()
11587 
    oprot.writeFieldStop()
11588 
    oprot.writeStructEnd()
11589 
 
3431 rajveer 11590 
  def validate(self):
11591 
    return
11592 
 
11593 
 
1113 chandransh 11594 
  def __repr__(self):
11595 
    L = ['%s=%r' % (key, value)
11596 
      for key, value in self.__dict__.iteritems()]
11597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11598 
 
11599 
  def __eq__(self, other):
11600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11601 
 
11602 
  def __ne__(self, other):
11603 
    return not (self == other)
11604 
 
3064 chandransh 11605 
class acceptOrder_result:
1113 chandransh 11606 
  """
11607 
  Attributes:
11608 
   - success
11609 
   - ex
11610 
  """
11611 
 
11612 
  thrift_spec = (
3064 chandransh 11613 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11614 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11615 
  )
11616 
 
11617 
  def __init__(self, success=None, ex=None,):
11618 
    self.success = success
11619 
    self.ex = ex
11620 
 
11621 
  def read(self, iprot):
11622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11624 
      return
11625 
    iprot.readStructBegin()
11626 
    while True:
11627 
      (fname, ftype, fid) = iprot.readFieldBegin()
11628 
      if ftype == TType.STOP:
11629 
        break
11630 
      if fid == 0:
3064 chandransh 11631 
        if ftype == TType.BOOL:
11632 
          self.success = iprot.readBool();
1113 chandransh 11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      elif fid == 1:
11636 
        if ftype == TType.STRUCT:
11637 
          self.ex = TransactionServiceException()
11638 
          self.ex.read(iprot)
11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
3064 chandransh 11650 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11651 
    if self.success is not None:
3064 chandransh 11652 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11653 
      oprot.writeBool(self.success)
1113 chandransh 11654 
      oprot.writeFieldEnd()
3431 rajveer 11655 
    if self.ex is not None:
1113 chandransh 11656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11657 
      self.ex.write(oprot)
11658 
      oprot.writeFieldEnd()
11659 
    oprot.writeFieldStop()
11660 
    oprot.writeStructEnd()
11661 
 
3431 rajveer 11662 
  def validate(self):
11663 
    return
11664 
 
11665 
 
1113 chandransh 11666 
  def __repr__(self):
11667 
    L = ['%s=%r' % (key, value)
11668 
      for key, value in self.__dict__.iteritems()]
11669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11670 
 
11671 
  def __eq__(self, other):
11672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11673 
 
11674 
  def __ne__(self, other):
11675 
    return not (self == other)
11676 
 
3064 chandransh 11677 
class addBillingDetails_args:
1135 chandransh 11678 
  """
11679 
  Attributes:
3064 chandransh 11680 
   - orderId
11681 
   - invoice_number
4658 mandeep.dh 11682 
   - serialNumber
4283 anupam.sin 11683 
   - itemNumber
3064 chandransh 11684 
   - billed_by
4264 rajveer 11685 
   - jacketNumber
4283 anupam.sin 11686 
   - billingType
5110 mandeep.dh 11687 
   - fulfilmentWarehouseId
4763 rajveer 11688 
   - authorize
1135 chandransh 11689 
  """
11690 
 
11691 
  thrift_spec = (
11692 
    None, # 0
3064 chandransh 11693 
    (1, TType.I64, 'orderId', None, None, ), # 1
11694 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 11695 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
11696 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 11697 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11698 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11699 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11700 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11701 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11702 
  )
11703 
 
5110 mandeep.dh 11704 
  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 11705 
    self.orderId = orderId
11706 
    self.invoice_number = invoice_number
4658 mandeep.dh 11707 
    self.serialNumber = serialNumber
4283 anupam.sin 11708 
    self.itemNumber = itemNumber
3064 chandransh 11709 
    self.billed_by = billed_by
4264 rajveer 11710 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11711 
    self.billingType = billingType
5110 mandeep.dh 11712 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11713 
    self.authorize = authorize
1135 chandransh 11714 
 
11715 
  def read(self, iprot):
11716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11718 
      return
11719 
    iprot.readStructBegin()
11720 
    while True:
11721 
      (fname, ftype, fid) = iprot.readFieldBegin()
11722 
      if ftype == TType.STOP:
11723 
        break
11724 
      if fid == 1:
11725 
        if ftype == TType.I64:
3064 chandransh 11726 
          self.orderId = iprot.readI64();
1135 chandransh 11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      elif fid == 2:
3064 chandransh 11730 
        if ftype == TType.STRING:
11731 
          self.invoice_number = iprot.readString();
1135 chandransh 11732 
        else:
11733 
          iprot.skip(ftype)
3064 chandransh 11734 
      elif fid == 3:
5411 rajveer 11735 
        if ftype == TType.LIST:
11736 
          self.serialNumber = []
11737 
          (_etype227, _size224) = iprot.readListBegin()
11738 
          for _i228 in xrange(_size224):
11739 
            _elem229 = iprot.readString();
11740 
            self.serialNumber.append(_elem229)
11741 
          iprot.readListEnd()
3064 chandransh 11742 
        else:
11743 
          iprot.skip(ftype)
11744 
      elif fid == 4:
5411 rajveer 11745 
        if ftype == TType.LIST:
11746 
          self.itemNumber = []
11747 
          (_etype233, _size230) = iprot.readListBegin()
11748 
          for _i234 in xrange(_size230):
11749 
            _elem235 = iprot.readString();
11750 
            self.itemNumber.append(_elem235)
11751 
          iprot.readListEnd()
3064 chandransh 11752 
        else:
11753 
          iprot.skip(ftype)
11754 
      elif fid == 5:
11755 
        if ftype == TType.STRING:
4283 anupam.sin 11756 
          self.billed_by = iprot.readString();
3064 chandransh 11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      elif fid == 6:
11760 
        if ftype == TType.I64:
4283 anupam.sin 11761 
          self.jacketNumber = iprot.readI64();
11762 
        else:
11763 
          iprot.skip(ftype)
11764 
      elif fid == 7:
11765 
        if ftype == TType.I64:
3064 chandransh 11766 
          self.billingType = iprot.readI64();
11767 
        else:
11768 
          iprot.skip(ftype)
4283 anupam.sin 11769 
      elif fid == 8:
11770 
        if ftype == TType.I64:
5110 mandeep.dh 11771 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11772 
        else:
11773 
          iprot.skip(ftype)
4763 rajveer 11774 
      elif fid == 9:
11775 
        if ftype == TType.BOOL:
11776 
          self.authorize = iprot.readBool();
11777 
        else:
11778 
          iprot.skip(ftype)
1246 chandransh 11779 
      else:
11780 
        iprot.skip(ftype)
11781 
      iprot.readFieldEnd()
11782 
    iprot.readStructEnd()
11783 
 
11784 
  def write(self, oprot):
11785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11787 
      return
4283 anupam.sin 11788 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11789 
    if self.orderId is not None:
3064 chandransh 11790 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11791 
      oprot.writeI64(self.orderId)
1246 chandransh 11792 
      oprot.writeFieldEnd()
4283 anupam.sin 11793 
    if self.invoice_number is not None:
11794 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11795 
      oprot.writeString(self.invoice_number)
1246 chandransh 11796 
      oprot.writeFieldEnd()
4658 mandeep.dh 11797 
    if self.serialNumber is not None:
5411 rajveer 11798 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
11799 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
11800 
      for iter236 in self.serialNumber:
11801 
        oprot.writeString(iter236)
11802 
      oprot.writeListEnd()
3064 chandransh 11803 
      oprot.writeFieldEnd()
3431 rajveer 11804 
    if self.itemNumber is not None:
5411 rajveer 11805 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
11806 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
11807 
      for iter237 in self.itemNumber:
11808 
        oprot.writeString(iter237)
11809 
      oprot.writeListEnd()
3064 chandransh 11810 
      oprot.writeFieldEnd()
4283 anupam.sin 11811 
    if self.billed_by is not None:
11812 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11813 
      oprot.writeString(self.billed_by)
3064 chandransh 11814 
      oprot.writeFieldEnd()
4283 anupam.sin 11815 
    if self.jacketNumber is not None:
11816 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11817 
      oprot.writeI64(self.jacketNumber)
11818 
      oprot.writeFieldEnd()
3431 rajveer 11819 
    if self.billingType is not None:
4283 anupam.sin 11820 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11821 
      oprot.writeI64(self.billingType)
11822 
      oprot.writeFieldEnd()
5110 mandeep.dh 11823 
    if self.fulfilmentWarehouseId is not None:
11824 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11825 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11826 
      oprot.writeFieldEnd()
4763 rajveer 11827 
    if self.authorize is not None:
11828 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11829 
      oprot.writeBool(self.authorize)
11830 
      oprot.writeFieldEnd()
1246 chandransh 11831 
    oprot.writeFieldStop()
11832 
    oprot.writeStructEnd()
11833 
 
3431 rajveer 11834 
  def validate(self):
11835 
    return
11836 
 
11837 
 
1246 chandransh 11838 
  def __repr__(self):
11839 
    L = ['%s=%r' % (key, value)
11840 
      for key, value in self.__dict__.iteritems()]
11841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11842 
 
11843 
  def __eq__(self, other):
11844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11845 
 
11846 
  def __ne__(self, other):
11847 
    return not (self == other)
11848 
 
4283 anupam.sin 11849 
class addBillingDetails_result:
1246 chandransh 11850 
  """
11851 
  Attributes:
3064 chandransh 11852 
   - success
1246 chandransh 11853 
   - ex
11854 
  """
11855 
 
11856 
  thrift_spec = (
3064 chandransh 11857 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11859 
  )
11860 
 
3064 chandransh 11861 
  def __init__(self, success=None, ex=None,):
11862 
    self.success = success
1246 chandransh 11863 
    self.ex = ex
11864 
 
11865 
  def read(self, iprot):
11866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11868 
      return
11869 
    iprot.readStructBegin()
11870 
    while True:
11871 
      (fname, ftype, fid) = iprot.readFieldBegin()
11872 
      if ftype == TType.STOP:
11873 
        break
3064 chandransh 11874 
      if fid == 0:
11875 
        if ftype == TType.BOOL:
11876 
          self.success = iprot.readBool();
11877 
        else:
11878 
          iprot.skip(ftype)
11879 
      elif fid == 1:
1246 chandransh 11880 
        if ftype == TType.STRUCT:
11881 
          self.ex = TransactionServiceException()
11882 
          self.ex.read(iprot)
11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      else:
11886 
        iprot.skip(ftype)
11887 
      iprot.readFieldEnd()
11888 
    iprot.readStructEnd()
11889 
 
11890 
  def write(self, oprot):
11891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11893 
      return
4283 anupam.sin 11894 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11895 
    if self.success is not None:
3064 chandransh 11896 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11897 
      oprot.writeBool(self.success)
11898 
      oprot.writeFieldEnd()
3431 rajveer 11899 
    if self.ex is not None:
1246 chandransh 11900 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11901 
      self.ex.write(oprot)
11902 
      oprot.writeFieldEnd()
11903 
    oprot.writeFieldStop()
11904 
    oprot.writeStructEnd()
11905 
 
3431 rajveer 11906 
  def validate(self):
11907 
    return
11908 
 
11909 
 
1246 chandransh 11910 
  def __repr__(self):
11911 
    L = ['%s=%r' % (key, value)
11912 
      for key, value in self.__dict__.iteritems()]
11913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11914 
 
11915 
  def __eq__(self, other):
11916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11917 
 
11918 
  def __ne__(self, other):
11919 
    return not (self == other)
11920 
 
4579 rajveer 11921 
class addInvoiceNumber_args:
11922 
  """
11923 
  Attributes:
11924 
   - orderId
11925 
   - invoiceNumber
4763 rajveer 11926 
   - color
4579 rajveer 11927 
  """
11928 
 
11929 
  thrift_spec = (
11930 
    None, # 0
11931 
    (1, TType.I64, 'orderId', None, None, ), # 1
11932 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11933 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11934 
  )
11935 
 
4763 rajveer 11936 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11937 
    self.orderId = orderId
11938 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11939 
    self.color = color
4579 rajveer 11940 
 
11941 
  def read(self, iprot):
11942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11944 
      return
11945 
    iprot.readStructBegin()
11946 
    while True:
11947 
      (fname, ftype, fid) = iprot.readFieldBegin()
11948 
      if ftype == TType.STOP:
11949 
        break
11950 
      if fid == 1:
11951 
        if ftype == TType.I64:
11952 
          self.orderId = iprot.readI64();
11953 
        else:
11954 
          iprot.skip(ftype)
11955 
      elif fid == 2:
11956 
        if ftype == TType.STRING:
11957 
          self.invoiceNumber = iprot.readString();
11958 
        else:
11959 
          iprot.skip(ftype)
4763 rajveer 11960 
      elif fid == 3:
11961 
        if ftype == TType.STRING:
11962 
          self.color = iprot.readString();
11963 
        else:
11964 
          iprot.skip(ftype)
4579 rajveer 11965 
      else:
11966 
        iprot.skip(ftype)
11967 
      iprot.readFieldEnd()
11968 
    iprot.readStructEnd()
11969 
 
11970 
  def write(self, oprot):
11971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11973 
      return
11974 
    oprot.writeStructBegin('addInvoiceNumber_args')
11975 
    if self.orderId is not None:
11976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11977 
      oprot.writeI64(self.orderId)
11978 
      oprot.writeFieldEnd()
11979 
    if self.invoiceNumber is not None:
11980 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11981 
      oprot.writeString(self.invoiceNumber)
11982 
      oprot.writeFieldEnd()
4763 rajveer 11983 
    if self.color is not None:
11984 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11985 
      oprot.writeString(self.color)
11986 
      oprot.writeFieldEnd()
4579 rajveer 11987 
    oprot.writeFieldStop()
11988 
    oprot.writeStructEnd()
11989 
 
11990 
  def validate(self):
11991 
    return
11992 
 
11993 
 
11994 
  def __repr__(self):
11995 
    L = ['%s=%r' % (key, value)
11996 
      for key, value in self.__dict__.iteritems()]
11997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11998 
 
11999 
  def __eq__(self, other):
12000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12001 
 
12002 
  def __ne__(self, other):
12003 
    return not (self == other)
12004 
 
12005 
class addInvoiceNumber_result:
12006 
  """
12007 
  Attributes:
12008 
   - ex
12009 
  """
12010 
 
12011 
  thrift_spec = (
12012 
    None, # 0
12013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12014 
  )
12015 
 
12016 
  def __init__(self, ex=None,):
12017 
    self.ex = ex
12018 
 
12019 
  def read(self, iprot):
12020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12022 
      return
12023 
    iprot.readStructBegin()
12024 
    while True:
12025 
      (fname, ftype, fid) = iprot.readFieldBegin()
12026 
      if ftype == TType.STOP:
12027 
        break
12028 
      if fid == 1:
12029 
        if ftype == TType.STRUCT:
12030 
          self.ex = TransactionServiceException()
12031 
          self.ex.read(iprot)
12032 
        else:
12033 
          iprot.skip(ftype)
12034 
      else:
12035 
        iprot.skip(ftype)
12036 
      iprot.readFieldEnd()
12037 
    iprot.readStructEnd()
12038 
 
12039 
  def write(self, oprot):
12040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12042 
      return
12043 
    oprot.writeStructBegin('addInvoiceNumber_result')
12044 
    if self.ex is not None:
12045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12046 
      self.ex.write(oprot)
12047 
      oprot.writeFieldEnd()
12048 
    oprot.writeFieldStop()
12049 
    oprot.writeStructEnd()
12050 
 
12051 
  def validate(self):
12052 
    return
12053 
 
12054 
 
12055 
  def __repr__(self):
12056 
    L = ['%s=%r' % (key, value)
12057 
      for key, value in self.__dict__.iteritems()]
12058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12059 
 
12060 
  def __eq__(self, other):
12061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12062 
 
12063 
  def __ne__(self, other):
12064 
    return not (self == other)
12065 
 
4910 phani.kuma 12066 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12067 
  """
12068 
  Attributes:
3064 chandransh 12069 
   - warehouseId
1408 ankur.sing 12070 
   - providerId
3064 chandransh 12071 
   - cod
4910 phani.kuma 12072 
   - orderIds
1408 ankur.sing 12073 
  """
12074 
 
12075 
  thrift_spec = (
12076 
    None, # 0
3064 chandransh 12077 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12078 
    (2, TType.I64, 'providerId', None, None, ), # 2
12079 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12080 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12081 
  )
12082 
 
4910 phani.kuma 12083 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12084 
    self.warehouseId = warehouseId
1408 ankur.sing 12085 
    self.providerId = providerId
3064 chandransh 12086 
    self.cod = cod
4910 phani.kuma 12087 
    self.orderIds = orderIds
1408 ankur.sing 12088 
 
12089 
  def read(self, iprot):
12090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12092 
      return
12093 
    iprot.readStructBegin()
12094 
    while True:
12095 
      (fname, ftype, fid) = iprot.readFieldBegin()
12096 
      if ftype == TType.STOP:
12097 
        break
12098 
      if fid == 1:
12099 
        if ftype == TType.I64:
3064 chandransh 12100 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12101 
        else:
12102 
          iprot.skip(ftype)
12103 
      elif fid == 2:
12104 
        if ftype == TType.I64:
3064 chandransh 12105 
          self.providerId = iprot.readI64();
1408 ankur.sing 12106 
        else:
12107 
          iprot.skip(ftype)
3064 chandransh 12108 
      elif fid == 3:
12109 
        if ftype == TType.BOOL:
12110 
          self.cod = iprot.readBool();
12111 
        else:
12112 
          iprot.skip(ftype)
4910 phani.kuma 12113 
      elif fid == 4:
12114 
        if ftype == TType.LIST:
12115 
          self.orderIds = []
5411 rajveer 12116 
          (_etype241, _size238) = iprot.readListBegin()
12117 
          for _i242 in xrange(_size238):
12118 
            _elem243 = iprot.readI64();
12119 
            self.orderIds.append(_elem243)
4910 phani.kuma 12120 
          iprot.readListEnd()
12121 
        else:
12122 
          iprot.skip(ftype)
1408 ankur.sing 12123 
      else:
12124 
        iprot.skip(ftype)
12125 
      iprot.readFieldEnd()
12126 
    iprot.readStructEnd()
12127 
 
12128 
  def write(self, oprot):
12129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12131 
      return
4910 phani.kuma 12132 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12133 
    if self.warehouseId is not None:
3064 chandransh 12134 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12135 
      oprot.writeI64(self.warehouseId)
12136 
      oprot.writeFieldEnd()
3431 rajveer 12137 
    if self.providerId is not None:
3064 chandransh 12138 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12139 
      oprot.writeI64(self.providerId)
12140 
      oprot.writeFieldEnd()
3431 rajveer 12141 
    if self.cod is not None:
3064 chandransh 12142 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12143 
      oprot.writeBool(self.cod)
1408 ankur.sing 12144 
      oprot.writeFieldEnd()
4910 phani.kuma 12145 
    if self.orderIds is not None:
12146 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12147 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12148 
      for iter244 in self.orderIds:
12149 
        oprot.writeI64(iter244)
4910 phani.kuma 12150 
      oprot.writeListEnd()
12151 
      oprot.writeFieldEnd()
1408 ankur.sing 12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
3431 rajveer 12155 
  def validate(self):
12156 
    return
12157 
 
12158 
 
1408 ankur.sing 12159 
  def __repr__(self):
12160 
    L = ['%s=%r' % (key, value)
12161 
      for key, value in self.__dict__.iteritems()]
12162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12163 
 
12164 
  def __eq__(self, other):
12165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12166 
 
12167 
  def __ne__(self, other):
12168 
    return not (self == other)
12169 
 
4910 phani.kuma 12170 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12171 
  """
12172 
  Attributes:
12173 
   - success
3064 chandransh 12174 
   - ex
1408 ankur.sing 12175 
  """
12176 
 
12177 
  thrift_spec = (
3064 chandransh 12178 
    (0, TType.BOOL, 'success', None, None, ), # 0
12179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12180 
  )
12181 
 
3064 chandransh 12182 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12183 
    self.success = success
3064 chandransh 12184 
    self.ex = ex
1408 ankur.sing 12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 0:
3064 chandransh 12196 
        if ftype == TType.BOOL:
12197 
          self.success = iprot.readBool();
1408 ankur.sing 12198 
        else:
12199 
          iprot.skip(ftype)
3064 chandransh 12200 
      elif fid == 1:
12201 
        if ftype == TType.STRUCT:
12202 
          self.ex = TransactionServiceException()
12203 
          self.ex.read(iprot)
12204 
        else:
12205 
          iprot.skip(ftype)
1408 ankur.sing 12206 
      else:
12207 
        iprot.skip(ftype)
12208 
      iprot.readFieldEnd()
12209 
    iprot.readStructEnd()
12210 
 
12211 
  def write(self, oprot):
12212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12214 
      return
4910 phani.kuma 12215 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12216 
    if self.success is not None:
3064 chandransh 12217 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12218 
      oprot.writeBool(self.success)
1408 ankur.sing 12219 
      oprot.writeFieldEnd()
3431 rajveer 12220 
    if self.ex is not None:
3064 chandransh 12221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12222 
      self.ex.write(oprot)
12223 
      oprot.writeFieldEnd()
1408 ankur.sing 12224 
    oprot.writeFieldStop()
12225 
    oprot.writeStructEnd()
12226 
 
3431 rajveer 12227 
  def validate(self):
12228 
    return
12229 
 
12230 
 
1408 ankur.sing 12231 
  def __repr__(self):
12232 
    L = ['%s=%r' % (key, value)
12233 
      for key, value in self.__dict__.iteritems()]
12234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12235 
 
12236 
  def __eq__(self, other):
12237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12238 
 
12239 
  def __ne__(self, other):
12240 
    return not (self == other)
12241 
 
4910 phani.kuma 12242 
class markOrdersAsPickedUp_args:
4410 rajveer 12243 
  """
12244 
  Attributes:
12245 
   - providerId
4910 phani.kuma 12246 
   - pickupDetails
4410 rajveer 12247 
  """
12248 
 
12249 
  thrift_spec = (
12250 
    None, # 0
4910 phani.kuma 12251 
    (1, TType.I64, 'providerId', None, None, ), # 1
12252 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12253 
  )
12254 
 
4910 phani.kuma 12255 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12256 
    self.providerId = providerId
4910 phani.kuma 12257 
    self.pickupDetails = pickupDetails
4410 rajveer 12258 
 
12259 
  def read(self, iprot):
12260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12262 
      return
12263 
    iprot.readStructBegin()
12264 
    while True:
12265 
      (fname, ftype, fid) = iprot.readFieldBegin()
12266 
      if ftype == TType.STOP:
12267 
        break
12268 
      if fid == 1:
12269 
        if ftype == TType.I64:
4910 phani.kuma 12270 
          self.providerId = iprot.readI64();
4410 rajveer 12271 
        else:
12272 
          iprot.skip(ftype)
12273 
      elif fid == 2:
4910 phani.kuma 12274 
        if ftype == TType.MAP:
12275 
          self.pickupDetails = {}
5411 rajveer 12276 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12277 
          for _i249 in xrange(_size245):
12278 
            _key250 = iprot.readString();
12279 
            _val251 = iprot.readString();
12280 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12281 
          iprot.readMapEnd()
4410 rajveer 12282 
        else:
12283 
          iprot.skip(ftype)
12284 
      else:
12285 
        iprot.skip(ftype)
12286 
      iprot.readFieldEnd()
12287 
    iprot.readStructEnd()
12288 
 
12289 
  def write(self, oprot):
12290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12292 
      return
4910 phani.kuma 12293 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12294 
    if self.providerId is not None:
4910 phani.kuma 12295 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12296 
      oprot.writeI64(self.providerId)
12297 
      oprot.writeFieldEnd()
4910 phani.kuma 12298 
    if self.pickupDetails is not None:
12299 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12300 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12301 
      for kiter252,viter253 in self.pickupDetails.items():
12302 
        oprot.writeString(kiter252)
12303 
        oprot.writeString(viter253)
4910 phani.kuma 12304 
      oprot.writeMapEnd()
4410 rajveer 12305 
      oprot.writeFieldEnd()
12306 
    oprot.writeFieldStop()
12307 
    oprot.writeStructEnd()
12308 
 
12309 
  def validate(self):
12310 
    return
12311 
 
12312 
 
12313 
  def __repr__(self):
12314 
    L = ['%s=%r' % (key, value)
12315 
      for key, value in self.__dict__.iteritems()]
12316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12317 
 
12318 
  def __eq__(self, other):
12319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12320 
 
12321 
  def __ne__(self, other):
12322 
    return not (self == other)
12323 
 
4910 phani.kuma 12324 
class markOrdersAsPickedUp_result:
4410 rajveer 12325 
  """
12326 
  Attributes:
12327 
   - ex
12328 
  """
12329 
 
12330 
  thrift_spec = (
4910 phani.kuma 12331 
    None, # 0
4410 rajveer 12332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12333 
  )
12334 
 
4910 phani.kuma 12335 
  def __init__(self, ex=None,):
4410 rajveer 12336 
    self.ex = ex
12337 
 
12338 
  def read(self, iprot):
12339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12341 
      return
12342 
    iprot.readStructBegin()
12343 
    while True:
12344 
      (fname, ftype, fid) = iprot.readFieldBegin()
12345 
      if ftype == TType.STOP:
12346 
        break
4910 phani.kuma 12347 
      if fid == 1:
4410 rajveer 12348 
        if ftype == TType.STRUCT:
12349 
          self.ex = TransactionServiceException()
12350 
          self.ex.read(iprot)
12351 
        else:
12352 
          iprot.skip(ftype)
12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
4910 phani.kuma 12362 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12363 
    if self.ex is not None:
12364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12365 
      self.ex.write(oprot)
12366 
      oprot.writeFieldEnd()
12367 
    oprot.writeFieldStop()
12368 
    oprot.writeStructEnd()
12369 
 
12370 
  def validate(self):
12371 
    return
12372 
 
12373 
 
12374 
  def __repr__(self):
12375 
    L = ['%s=%r' % (key, value)
12376 
      for key, value in self.__dict__.iteritems()]
12377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12378 
 
12379 
  def __eq__(self, other):
12380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12381 
 
12382 
  def __ne__(self, other):
12383 
    return not (self == other)
12384 
 
4910 phani.kuma 12385 
class getOrdersNotPickedUp_args:
304 ashish 12386 
  """
12387 
  Attributes:
3064 chandransh 12388 
   - providerId
304 ashish 12389 
  """
94 ashish 12390 
 
304 ashish 12391 
  thrift_spec = (
12392 
    None, # 0
3064 chandransh 12393 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12394 
  )
12395 
 
4910 phani.kuma 12396 
  def __init__(self, providerId=None,):
3064 chandransh 12397 
    self.providerId = providerId
304 ashish 12398 
 
12399 
  def read(self, iprot):
12400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12402 
      return
12403 
    iprot.readStructBegin()
12404 
    while True:
12405 
      (fname, ftype, fid) = iprot.readFieldBegin()
12406 
      if ftype == TType.STOP:
12407 
        break
12408 
      if fid == 1:
12409 
        if ftype == TType.I64:
3064 chandransh 12410 
          self.providerId = iprot.readI64();
304 ashish 12411 
        else:
12412 
          iprot.skip(ftype)
12413 
      else:
12414 
        iprot.skip(ftype)
12415 
      iprot.readFieldEnd()
12416 
    iprot.readStructEnd()
12417 
 
12418 
  def write(self, oprot):
12419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12421 
      return
4910 phani.kuma 12422 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12423 
    if self.providerId is not None:
3064 chandransh 12424 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12425 
      oprot.writeI64(self.providerId)
304 ashish 12426 
      oprot.writeFieldEnd()
12427 
    oprot.writeFieldStop()
12428 
    oprot.writeStructEnd()
12429 
 
3431 rajveer 12430 
  def validate(self):
12431 
    return
12432 
 
12433 
 
304 ashish 12434 
  def __repr__(self):
12435 
    L = ['%s=%r' % (key, value)
12436 
      for key, value in self.__dict__.iteritems()]
12437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12438 
 
12439 
  def __eq__(self, other):
12440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12441 
 
12442 
  def __ne__(self, other):
12443 
    return not (self == other)
12444 
 
4910 phani.kuma 12445 
class getOrdersNotPickedUp_result:
304 ashish 12446 
  """
12447 
  Attributes:
12448 
   - success
12449 
  """
12450 
 
12451 
  thrift_spec = (
3064 chandransh 12452 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12453 
  )
12454 
 
4910 phani.kuma 12455 
  def __init__(self, success=None,):
304 ashish 12456 
    self.success = success
12457 
 
12458 
  def read(self, iprot):
12459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12461 
      return
12462 
    iprot.readStructBegin()
12463 
    while True:
12464 
      (fname, ftype, fid) = iprot.readFieldBegin()
12465 
      if ftype == TType.STOP:
12466 
        break
12467 
      if fid == 0:
12468 
        if ftype == TType.LIST:
12469 
          self.success = []
5411 rajveer 12470 
          (_etype257, _size254) = iprot.readListBegin()
12471 
          for _i258 in xrange(_size254):
12472 
            _elem259 = Order()
12473 
            _elem259.read(iprot)
12474 
            self.success.append(_elem259)
304 ashish 12475 
          iprot.readListEnd()
12476 
        else:
12477 
          iprot.skip(ftype)
12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
4910 phani.kuma 12487 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12488 
    if self.success is not None:
304 ashish 12489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12490 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12491 
      for iter260 in self.success:
12492 
        iter260.write(oprot)
304 ashish 12493 
      oprot.writeListEnd()
12494 
      oprot.writeFieldEnd()
12495 
    oprot.writeFieldStop()
12496 
    oprot.writeStructEnd()
12497 
 
3431 rajveer 12498 
  def validate(self):
12499 
    return
12500 
 
12501 
 
304 ashish 12502 
  def __repr__(self):
12503 
    L = ['%s=%r' % (key, value)
12504 
      for key, value in self.__dict__.iteritems()]
12505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12506 
 
12507 
  def __eq__(self, other):
12508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12509 
 
12510 
  def __ne__(self, other):
12511 
    return not (self == other)
12512 
 
3064 chandransh 12513 
class markOrdersAsDelivered_args:
304 ashish 12514 
  """
12515 
  Attributes:
3064 chandransh 12516 
   - providerId
12517 
   - deliveredOrders
304 ashish 12518 
  """
12519 
 
12520 
  thrift_spec = (
12521 
    None, # 0
3064 chandransh 12522 
    (1, TType.I64, 'providerId', None, None, ), # 1
12523 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12524 
  )
12525 
 
3064 chandransh 12526 
  def __init__(self, providerId=None, deliveredOrders=None,):
12527 
    self.providerId = providerId
12528 
    self.deliveredOrders = deliveredOrders
304 ashish 12529 
 
12530 
  def read(self, iprot):
12531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12533 
      return
12534 
    iprot.readStructBegin()
12535 
    while True:
12536 
      (fname, ftype, fid) = iprot.readFieldBegin()
12537 
      if ftype == TType.STOP:
12538 
        break
12539 
      if fid == 1:
12540 
        if ftype == TType.I64:
3064 chandransh 12541 
          self.providerId = iprot.readI64();
304 ashish 12542 
        else:
12543 
          iprot.skip(ftype)
12544 
      elif fid == 2:
3064 chandransh 12545 
        if ftype == TType.MAP:
12546 
          self.deliveredOrders = {}
5411 rajveer 12547 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
12548 
          for _i265 in xrange(_size261):
12549 
            _key266 = iprot.readString();
12550 
            _val267 = iprot.readString();
12551 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 12552 
          iprot.readMapEnd()
304 ashish 12553 
        else:
12554 
          iprot.skip(ftype)
12555 
      else:
12556 
        iprot.skip(ftype)
12557 
      iprot.readFieldEnd()
12558 
    iprot.readStructEnd()
12559 
 
12560 
  def write(self, oprot):
12561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12563 
      return
3064 chandransh 12564 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12565 
    if self.providerId is not None:
3064 chandransh 12566 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12567 
      oprot.writeI64(self.providerId)
304 ashish 12568 
      oprot.writeFieldEnd()
3431 rajveer 12569 
    if self.deliveredOrders is not None:
3064 chandransh 12570 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12571 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 12572 
      for kiter268,viter269 in self.deliveredOrders.items():
12573 
        oprot.writeString(kiter268)
12574 
        oprot.writeString(viter269)
3064 chandransh 12575 
      oprot.writeMapEnd()
304 ashish 12576 
      oprot.writeFieldEnd()
12577 
    oprot.writeFieldStop()
12578 
    oprot.writeStructEnd()
12579 
 
3431 rajveer 12580 
  def validate(self):
12581 
    return
12582 
 
12583 
 
304 ashish 12584 
  def __repr__(self):
12585 
    L = ['%s=%r' % (key, value)
12586 
      for key, value in self.__dict__.iteritems()]
12587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12588 
 
12589 
  def __eq__(self, other):
12590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12591 
 
12592 
  def __ne__(self, other):
12593 
    return not (self == other)
12594 
 
3064 chandransh 12595 
class markOrdersAsDelivered_result:
12596 
  """
12597 
  Attributes:
12598 
   - ex
12599 
  """
304 ashish 12600 
 
12601 
  thrift_spec = (
3064 chandransh 12602 
    None, # 0
12603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12604 
  )
12605 
 
3064 chandransh 12606 
  def __init__(self, ex=None,):
12607 
    self.ex = ex
304 ashish 12608 
 
1596 ankur.sing 12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
3064 chandransh 12618 
      if fid == 1:
12619 
        if ftype == TType.STRUCT:
12620 
          self.ex = TransactionServiceException()
12621 
          self.ex.read(iprot)
12622 
        else:
12623 
          iprot.skip(ftype)
1596 ankur.sing 12624 
      else:
12625 
        iprot.skip(ftype)
12626 
      iprot.readFieldEnd()
12627 
    iprot.readStructEnd()
12628 
 
12629 
  def write(self, oprot):
12630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12632 
      return
3064 chandransh 12633 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12634 
    if self.ex is not None:
3064 chandransh 12635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12636 
      self.ex.write(oprot)
12637 
      oprot.writeFieldEnd()
1596 ankur.sing 12638 
    oprot.writeFieldStop()
12639 
    oprot.writeStructEnd()
12640 
 
3431 rajveer 12641 
  def validate(self):
12642 
    return
12643 
 
12644 
 
1596 ankur.sing 12645 
  def __repr__(self):
12646 
    L = ['%s=%r' % (key, value)
12647 
      for key, value in self.__dict__.iteritems()]
12648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12649 
 
12650 
  def __eq__(self, other):
12651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12652 
 
12653 
  def __ne__(self, other):
12654 
    return not (self == other)
12655 
 
4910 phani.kuma 12656 
class markAsRTOrders_args:
1596 ankur.sing 12657 
  """
12658 
  Attributes:
3064 chandransh 12659 
   - providerId
12660 
   - returnedOrders
1596 ankur.sing 12661 
  """
12662 
 
12663 
  thrift_spec = (
3064 chandransh 12664 
    None, # 0
12665 
    (1, TType.I64, 'providerId', None, None, ), # 1
12666 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12667 
  )
12668 
 
3064 chandransh 12669 
  def __init__(self, providerId=None, returnedOrders=None,):
12670 
    self.providerId = providerId
12671 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12672 
 
12673 
  def read(self, iprot):
12674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12676 
      return
12677 
    iprot.readStructBegin()
12678 
    while True:
12679 
      (fname, ftype, fid) = iprot.readFieldBegin()
12680 
      if ftype == TType.STOP:
12681 
        break
3064 chandransh 12682 
      if fid == 1:
1596 ankur.sing 12683 
        if ftype == TType.I64:
3064 chandransh 12684 
          self.providerId = iprot.readI64();
1596 ankur.sing 12685 
        else:
12686 
          iprot.skip(ftype)
3064 chandransh 12687 
      elif fid == 2:
12688 
        if ftype == TType.MAP:
12689 
          self.returnedOrders = {}
5411 rajveer 12690 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
12691 
          for _i274 in xrange(_size270):
12692 
            _key275 = iprot.readString();
12693 
            _val276 = iprot.readString();
12694 
            self.returnedOrders[_key275] = _val276
3064 chandransh 12695 
          iprot.readMapEnd()
12696 
        else:
12697 
          iprot.skip(ftype)
1596 ankur.sing 12698 
      else:
12699 
        iprot.skip(ftype)
12700 
      iprot.readFieldEnd()
12701 
    iprot.readStructEnd()
12702 
 
12703 
  def write(self, oprot):
12704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12706 
      return
4910 phani.kuma 12707 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12708 
    if self.providerId is not None:
3064 chandransh 12709 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12710 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12711 
      oprot.writeFieldEnd()
3431 rajveer 12712 
    if self.returnedOrders is not None:
3064 chandransh 12713 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12714 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 12715 
      for kiter277,viter278 in self.returnedOrders.items():
12716 
        oprot.writeString(kiter277)
12717 
        oprot.writeString(viter278)
3064 chandransh 12718 
      oprot.writeMapEnd()
12719 
      oprot.writeFieldEnd()
1596 ankur.sing 12720 
    oprot.writeFieldStop()
12721 
    oprot.writeStructEnd()
12722 
 
3431 rajveer 12723 
  def validate(self):
12724 
    return
12725 
 
12726 
 
1596 ankur.sing 12727 
  def __repr__(self):
12728 
    L = ['%s=%r' % (key, value)
12729 
      for key, value in self.__dict__.iteritems()]
12730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12731 
 
12732 
  def __eq__(self, other):
12733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12734 
 
12735 
  def __ne__(self, other):
12736 
    return not (self == other)
12737 
 
4910 phani.kuma 12738 
class markAsRTOrders_result:
3064 chandransh 12739 
  """
12740 
  Attributes:
12741 
   - ex
12742 
  """
1596 ankur.sing 12743 
 
1627 ankur.sing 12744 
  thrift_spec = (
3064 chandransh 12745 
    None, # 0
12746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12747 
  )
12748 
 
3064 chandransh 12749 
  def __init__(self, ex=None,):
12750 
    self.ex = ex
12751 
 
1627 ankur.sing 12752 
  def read(self, iprot):
12753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12755 
      return
12756 
    iprot.readStructBegin()
12757 
    while True:
12758 
      (fname, ftype, fid) = iprot.readFieldBegin()
12759 
      if ftype == TType.STOP:
12760 
        break
3064 chandransh 12761 
      if fid == 1:
12762 
        if ftype == TType.STRUCT:
12763 
          self.ex = TransactionServiceException()
12764 
          self.ex.read(iprot)
12765 
        else:
12766 
          iprot.skip(ftype)
1627 ankur.sing 12767 
      else:
12768 
        iprot.skip(ftype)
12769 
      iprot.readFieldEnd()
12770 
    iprot.readStructEnd()
12771 
 
12772 
  def write(self, oprot):
12773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12775 
      return
4910 phani.kuma 12776 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12777 
    if self.ex is not None:
3064 chandransh 12778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12779 
      self.ex.write(oprot)
12780 
      oprot.writeFieldEnd()
1627 ankur.sing 12781 
    oprot.writeFieldStop()
12782 
    oprot.writeStructEnd()
12783 
 
3431 rajveer 12784 
  def validate(self):
12785 
    return
12786 
 
12787 
 
1627 ankur.sing 12788 
  def __repr__(self):
12789 
    L = ['%s=%r' % (key, value)
12790 
      for key, value in self.__dict__.iteritems()]
12791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12792 
 
12793 
  def __eq__(self, other):
12794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12795 
 
12796 
  def __ne__(self, other):
12797 
    return not (self == other)
12798 
 
4910 phani.kuma 12799 
class getRTOrders_args:
12800 
  """
12801 
  Attributes:
12802 
   - providerId
12803 
  """
12804 
 
12805 
  thrift_spec = (
12806 
    None, # 0
12807 
    (1, TType.I64, 'providerId', None, None, ), # 1
12808 
  )
12809 
 
12810 
  def __init__(self, providerId=None,):
12811 
    self.providerId = providerId
12812 
 
12813 
  def read(self, iprot):
12814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12816 
      return
12817 
    iprot.readStructBegin()
12818 
    while True:
12819 
      (fname, ftype, fid) = iprot.readFieldBegin()
12820 
      if ftype == TType.STOP:
12821 
        break
12822 
      if fid == 1:
12823 
        if ftype == TType.I64:
12824 
          self.providerId = iprot.readI64();
12825 
        else:
12826 
          iprot.skip(ftype)
12827 
      else:
12828 
        iprot.skip(ftype)
12829 
      iprot.readFieldEnd()
12830 
    iprot.readStructEnd()
12831 
 
12832 
  def write(self, oprot):
12833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12835 
      return
12836 
    oprot.writeStructBegin('getRTOrders_args')
12837 
    if self.providerId is not None:
12838 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12839 
      oprot.writeI64(self.providerId)
12840 
      oprot.writeFieldEnd()
12841 
    oprot.writeFieldStop()
12842 
    oprot.writeStructEnd()
12843 
 
12844 
  def validate(self):
12845 
    return
12846 
 
12847 
 
12848 
  def __repr__(self):
12849 
    L = ['%s=%r' % (key, value)
12850 
      for key, value in self.__dict__.iteritems()]
12851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12852 
 
12853 
  def __eq__(self, other):
12854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12855 
 
12856 
  def __ne__(self, other):
12857 
    return not (self == other)
12858 
 
12859 
class getRTOrders_result:
12860 
  """
12861 
  Attributes:
12862 
   - success
12863 
  """
12864 
 
12865 
  thrift_spec = (
12866 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12867 
  )
12868 
 
12869 
  def __init__(self, success=None,):
12870 
    self.success = success
12871 
 
12872 
  def read(self, iprot):
12873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12875 
      return
12876 
    iprot.readStructBegin()
12877 
    while True:
12878 
      (fname, ftype, fid) = iprot.readFieldBegin()
12879 
      if ftype == TType.STOP:
12880 
        break
12881 
      if fid == 0:
12882 
        if ftype == TType.LIST:
12883 
          self.success = []
5411 rajveer 12884 
          (_etype282, _size279) = iprot.readListBegin()
12885 
          for _i283 in xrange(_size279):
12886 
            _elem284 = Order()
12887 
            _elem284.read(iprot)
12888 
            self.success.append(_elem284)
4910 phani.kuma 12889 
          iprot.readListEnd()
12890 
        else:
12891 
          iprot.skip(ftype)
12892 
      else:
12893 
        iprot.skip(ftype)
12894 
      iprot.readFieldEnd()
12895 
    iprot.readStructEnd()
12896 
 
12897 
  def write(self, oprot):
12898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12900 
      return
12901 
    oprot.writeStructBegin('getRTOrders_result')
12902 
    if self.success is not None:
12903 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12904 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12905 
      for iter285 in self.success:
12906 
        iter285.write(oprot)
4910 phani.kuma 12907 
      oprot.writeListEnd()
12908 
      oprot.writeFieldEnd()
12909 
    oprot.writeFieldStop()
12910 
    oprot.writeStructEnd()
12911 
 
12912 
  def validate(self):
12913 
    return
12914 
 
12915 
 
12916 
  def __repr__(self):
12917 
    L = ['%s=%r' % (key, value)
12918 
      for key, value in self.__dict__.iteritems()]
12919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12920 
 
12921 
  def __eq__(self, other):
12922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12923 
 
12924 
  def __ne__(self, other):
12925 
    return not (self == other)
12926 
 
3064 chandransh 12927 
class updateNonDeliveryReason_args:
1627 ankur.sing 12928 
  """
12929 
  Attributes:
3064 chandransh 12930 
   - providerId
12931 
   - undeliveredOrders
1627 ankur.sing 12932 
  """
12933 
 
12934 
  thrift_spec = (
3064 chandransh 12935 
    None, # 0
12936 
    (1, TType.I64, 'providerId', None, None, ), # 1
12937 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12938 
  )
12939 
 
3064 chandransh 12940 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12941 
    self.providerId = providerId
12942 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12943 
 
12944 
  def read(self, iprot):
12945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12947 
      return
12948 
    iprot.readStructBegin()
12949 
    while True:
12950 
      (fname, ftype, fid) = iprot.readFieldBegin()
12951 
      if ftype == TType.STOP:
12952 
        break
3064 chandransh 12953 
      if fid == 1:
1627 ankur.sing 12954 
        if ftype == TType.I64:
3064 chandransh 12955 
          self.providerId = iprot.readI64();
1627 ankur.sing 12956 
        else:
12957 
          iprot.skip(ftype)
3064 chandransh 12958 
      elif fid == 2:
12959 
        if ftype == TType.MAP:
12960 
          self.undeliveredOrders = {}
5411 rajveer 12961 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
12962 
          for _i290 in xrange(_size286):
12963 
            _key291 = iprot.readString();
12964 
            _val292 = iprot.readString();
12965 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 12966 
          iprot.readMapEnd()
12967 
        else:
12968 
          iprot.skip(ftype)
1627 ankur.sing 12969 
      else:
12970 
        iprot.skip(ftype)
12971 
      iprot.readFieldEnd()
12972 
    iprot.readStructEnd()
12973 
 
12974 
  def write(self, oprot):
12975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12977 
      return
3064 chandransh 12978 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12979 
    if self.providerId is not None:
3064 chandransh 12980 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12981 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12982 
      oprot.writeFieldEnd()
3431 rajveer 12983 
    if self.undeliveredOrders is not None:
3064 chandransh 12984 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12985 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 12986 
      for kiter293,viter294 in self.undeliveredOrders.items():
12987 
        oprot.writeString(kiter293)
12988 
        oprot.writeString(viter294)
3064 chandransh 12989 
      oprot.writeMapEnd()
12990 
      oprot.writeFieldEnd()
1627 ankur.sing 12991 
    oprot.writeFieldStop()
12992 
    oprot.writeStructEnd()
12993 
 
3431 rajveer 12994 
  def validate(self):
12995 
    return
12996 
 
12997 
 
1627 ankur.sing 12998 
  def __repr__(self):
12999 
    L = ['%s=%r' % (key, value)
13000 
      for key, value in self.__dict__.iteritems()]
13001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13002 
 
13003 
  def __eq__(self, other):
13004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13005 
 
13006 
  def __ne__(self, other):
13007 
    return not (self == other)
13008 
 
3064 chandransh 13009 
class updateNonDeliveryReason_result:
1627 ankur.sing 13010 
  """
13011 
  Attributes:
3064 chandransh 13012 
   - ex
1627 ankur.sing 13013 
  """
13014 
 
13015 
  thrift_spec = (
4910 phani.kuma 13016 
    None, # 0
3064 chandransh 13017 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13018 
  )
13019 
 
4910 phani.kuma 13020 
  def __init__(self, ex=None,):
3064 chandransh 13021 
    self.ex = ex
1627 ankur.sing 13022 
 
13023 
  def read(self, iprot):
13024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13026 
      return
13027 
    iprot.readStructBegin()
13028 
    while True:
13029 
      (fname, ftype, fid) = iprot.readFieldBegin()
13030 
      if ftype == TType.STOP:
13031 
        break
4910 phani.kuma 13032 
      if fid == 1:
13033 
        if ftype == TType.STRUCT:
13034 
          self.ex = TransactionServiceException()
13035 
          self.ex.read(iprot)
13036 
        else:
13037 
          iprot.skip(ftype)
13038 
      else:
13039 
        iprot.skip(ftype)
13040 
      iprot.readFieldEnd()
13041 
    iprot.readStructEnd()
13042 
 
13043 
  def write(self, oprot):
13044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13046 
      return
13047 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13048 
    if self.ex is not None:
13049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13050 
      self.ex.write(oprot)
13051 
      oprot.writeFieldEnd()
13052 
    oprot.writeFieldStop()
13053 
    oprot.writeStructEnd()
13054 
 
13055 
  def validate(self):
13056 
    return
13057 
 
13058 
 
13059 
  def __repr__(self):
13060 
    L = ['%s=%r' % (key, value)
13061 
      for key, value in self.__dict__.iteritems()]
13062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13063 
 
13064 
  def __eq__(self, other):
13065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13066 
 
13067 
  def __ne__(self, other):
13068 
    return not (self == other)
13069 
 
13070 
class getNonDeliveredOrdersbyCourier_args:
13071 
  """
13072 
  Attributes:
13073 
   - providerId
13074 
  """
13075 
 
13076 
  thrift_spec = (
13077 
    None, # 0
13078 
    (1, TType.I64, 'providerId', None, None, ), # 1
13079 
  )
13080 
 
13081 
  def __init__(self, providerId=None,):
13082 
    self.providerId = providerId
13083 
 
13084 
  def read(self, iprot):
13085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13087 
      return
13088 
    iprot.readStructBegin()
13089 
    while True:
13090 
      (fname, ftype, fid) = iprot.readFieldBegin()
13091 
      if ftype == TType.STOP:
13092 
        break
13093 
      if fid == 1:
13094 
        if ftype == TType.I64:
13095 
          self.providerId = iprot.readI64();
13096 
        else:
13097 
          iprot.skip(ftype)
13098 
      else:
13099 
        iprot.skip(ftype)
13100 
      iprot.readFieldEnd()
13101 
    iprot.readStructEnd()
13102 
 
13103 
  def write(self, oprot):
13104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13106 
      return
13107 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13108 
    if self.providerId is not None:
13109 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13110 
      oprot.writeI64(self.providerId)
13111 
      oprot.writeFieldEnd()
13112 
    oprot.writeFieldStop()
13113 
    oprot.writeStructEnd()
13114 
 
13115 
  def validate(self):
13116 
    return
13117 
 
13118 
 
13119 
  def __repr__(self):
13120 
    L = ['%s=%r' % (key, value)
13121 
      for key, value in self.__dict__.iteritems()]
13122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13123 
 
13124 
  def __eq__(self, other):
13125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13126 
 
13127 
  def __ne__(self, other):
13128 
    return not (self == other)
13129 
 
13130 
class getNonDeliveredOrdersbyCourier_result:
13131 
  """
13132 
  Attributes:
13133 
   - success
13134 
  """
13135 
 
13136 
  thrift_spec = (
13137 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13138 
  )
13139 
 
13140 
  def __init__(self, success=None,):
13141 
    self.success = success
13142 
 
13143 
  def read(self, iprot):
13144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13146 
      return
13147 
    iprot.readStructBegin()
13148 
    while True:
13149 
      (fname, ftype, fid) = iprot.readFieldBegin()
13150 
      if ftype == TType.STOP:
13151 
        break
4581 phani.kuma 13152 
      if fid == 0:
13153 
        if ftype == TType.LIST:
13154 
          self.success = []
5411 rajveer 13155 
          (_etype298, _size295) = iprot.readListBegin()
13156 
          for _i299 in xrange(_size295):
13157 
            _elem300 = Order()
13158 
            _elem300.read(iprot)
13159 
            self.success.append(_elem300)
4581 phani.kuma 13160 
          iprot.readListEnd()
13161 
        else:
13162 
          iprot.skip(ftype)
4910 phani.kuma 13163 
      else:
13164 
        iprot.skip(ftype)
13165 
      iprot.readFieldEnd()
13166 
    iprot.readStructEnd()
13167 
 
13168 
  def write(self, oprot):
13169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13171 
      return
13172 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13173 
    if self.success is not None:
13174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13176 
      for iter301 in self.success:
13177 
        iter301.write(oprot)
4910 phani.kuma 13178 
      oprot.writeListEnd()
13179 
      oprot.writeFieldEnd()
13180 
    oprot.writeFieldStop()
13181 
    oprot.writeStructEnd()
13182 
 
13183 
  def validate(self):
13184 
    return
13185 
 
13186 
 
13187 
  def __repr__(self):
13188 
    L = ['%s=%r' % (key, value)
13189 
      for key, value in self.__dict__.iteritems()]
13190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13191 
 
13192 
  def __eq__(self, other):
13193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13194 
 
13195 
  def __ne__(self, other):
13196 
    return not (self == other)
13197 
 
13198 
class markOrdersAsLocalConnected_args:
13199 
  """
13200 
  Attributes:
13201 
   - providerId
13202 
   - local_connected_orders
13203 
  """
13204 
 
13205 
  thrift_spec = (
13206 
    None, # 0
13207 
    (1, TType.I64, 'providerId', None, None, ), # 1
13208 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13209 
  )
13210 
 
13211 
  def __init__(self, providerId=None, local_connected_orders=None,):
13212 
    self.providerId = providerId
13213 
    self.local_connected_orders = local_connected_orders
13214 
 
13215 
  def read(self, iprot):
13216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13218 
      return
13219 
    iprot.readStructBegin()
13220 
    while True:
13221 
      (fname, ftype, fid) = iprot.readFieldBegin()
13222 
      if ftype == TType.STOP:
13223 
        break
13224 
      if fid == 1:
13225 
        if ftype == TType.I64:
13226 
          self.providerId = iprot.readI64();
13227 
        else:
13228 
          iprot.skip(ftype)
13229 
      elif fid == 2:
13230 
        if ftype == TType.MAP:
13231 
          self.local_connected_orders = {}
5411 rajveer 13232 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13233 
          for _i306 in xrange(_size302):
13234 
            _key307 = iprot.readString();
13235 
            _val308 = iprot.readString();
13236 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13237 
          iprot.readMapEnd()
13238 
        else:
13239 
          iprot.skip(ftype)
13240 
      else:
13241 
        iprot.skip(ftype)
13242 
      iprot.readFieldEnd()
13243 
    iprot.readStructEnd()
13244 
 
13245 
  def write(self, oprot):
13246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13248 
      return
13249 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13250 
    if self.providerId is not None:
13251 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13252 
      oprot.writeI64(self.providerId)
13253 
      oprot.writeFieldEnd()
13254 
    if self.local_connected_orders is not None:
13255 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13256 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13257 
      for kiter309,viter310 in self.local_connected_orders.items():
13258 
        oprot.writeString(kiter309)
13259 
        oprot.writeString(viter310)
4910 phani.kuma 13260 
      oprot.writeMapEnd()
13261 
      oprot.writeFieldEnd()
13262 
    oprot.writeFieldStop()
13263 
    oprot.writeStructEnd()
13264 
 
13265 
  def validate(self):
13266 
    return
13267 
 
13268 
 
13269 
  def __repr__(self):
13270 
    L = ['%s=%r' % (key, value)
13271 
      for key, value in self.__dict__.iteritems()]
13272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13273 
 
13274 
  def __eq__(self, other):
13275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13276 
 
13277 
  def __ne__(self, other):
13278 
    return not (self == other)
13279 
 
13280 
class markOrdersAsLocalConnected_result:
13281 
  """
13282 
  Attributes:
13283 
   - ex
13284 
  """
13285 
 
13286 
  thrift_spec = (
13287 
    None, # 0
13288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13289 
  )
13290 
 
13291 
  def __init__(self, ex=None,):
13292 
    self.ex = ex
13293 
 
13294 
  def read(self, iprot):
13295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13297 
      return
13298 
    iprot.readStructBegin()
13299 
    while True:
13300 
      (fname, ftype, fid) = iprot.readFieldBegin()
13301 
      if ftype == TType.STOP:
13302 
        break
13303 
      if fid == 1:
3064 chandransh 13304 
        if ftype == TType.STRUCT:
13305 
          self.ex = TransactionServiceException()
13306 
          self.ex.read(iprot)
1627 ankur.sing 13307 
        else:
13308 
          iprot.skip(ftype)
13309 
      else:
13310 
        iprot.skip(ftype)
13311 
      iprot.readFieldEnd()
13312 
    iprot.readStructEnd()
13313 
 
13314 
  def write(self, oprot):
13315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13317 
      return
4910 phani.kuma 13318 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13319 
    if self.ex is not None:
13320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13321 
      self.ex.write(oprot)
13322 
      oprot.writeFieldEnd()
13323 
    oprot.writeFieldStop()
13324 
    oprot.writeStructEnd()
13325 
 
13326 
  def validate(self):
13327 
    return
13328 
 
13329 
 
13330 
  def __repr__(self):
13331 
    L = ['%s=%r' % (key, value)
13332 
      for key, value in self.__dict__.iteritems()]
13333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13334 
 
13335 
  def __eq__(self, other):
13336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13337 
 
13338 
  def __ne__(self, other):
13339 
    return not (self == other)
13340 
 
13341 
class getOrdersNotLocalConnected_args:
13342 
  """
13343 
  Attributes:
13344 
   - providerId
13345 
  """
13346 
 
13347 
  thrift_spec = (
13348 
    None, # 0
13349 
    (1, TType.I64, 'providerId', None, None, ), # 1
13350 
  )
13351 
 
13352 
  def __init__(self, providerId=None,):
13353 
    self.providerId = providerId
13354 
 
13355 
  def read(self, iprot):
13356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13358 
      return
13359 
    iprot.readStructBegin()
13360 
    while True:
13361 
      (fname, ftype, fid) = iprot.readFieldBegin()
13362 
      if ftype == TType.STOP:
13363 
        break
13364 
      if fid == 1:
13365 
        if ftype == TType.I64:
13366 
          self.providerId = iprot.readI64();
13367 
        else:
13368 
          iprot.skip(ftype)
13369 
      else:
13370 
        iprot.skip(ftype)
13371 
      iprot.readFieldEnd()
13372 
    iprot.readStructEnd()
13373 
 
13374 
  def write(self, oprot):
13375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13377 
      return
13378 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13379 
    if self.providerId is not None:
13380 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13381 
      oprot.writeI64(self.providerId)
13382 
      oprot.writeFieldEnd()
13383 
    oprot.writeFieldStop()
13384 
    oprot.writeStructEnd()
13385 
 
13386 
  def validate(self):
13387 
    return
13388 
 
13389 
 
13390 
  def __repr__(self):
13391 
    L = ['%s=%r' % (key, value)
13392 
      for key, value in self.__dict__.iteritems()]
13393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13394 
 
13395 
  def __eq__(self, other):
13396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13397 
 
13398 
  def __ne__(self, other):
13399 
    return not (self == other)
13400 
 
13401 
class getOrdersNotLocalConnected_result:
13402 
  """
13403 
  Attributes:
13404 
   - success
13405 
  """
13406 
 
13407 
  thrift_spec = (
13408 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13409 
  )
13410 
 
13411 
  def __init__(self, success=None,):
13412 
    self.success = success
13413 
 
13414 
  def read(self, iprot):
13415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13417 
      return
13418 
    iprot.readStructBegin()
13419 
    while True:
13420 
      (fname, ftype, fid) = iprot.readFieldBegin()
13421 
      if ftype == TType.STOP:
13422 
        break
13423 
      if fid == 0:
13424 
        if ftype == TType.LIST:
13425 
          self.success = []
5411 rajveer 13426 
          (_etype314, _size311) = iprot.readListBegin()
13427 
          for _i315 in xrange(_size311):
13428 
            _elem316 = Order()
13429 
            _elem316.read(iprot)
13430 
            self.success.append(_elem316)
4910 phani.kuma 13431 
          iprot.readListEnd()
13432 
        else:
13433 
          iprot.skip(ftype)
13434 
      else:
13435 
        iprot.skip(ftype)
13436 
      iprot.readFieldEnd()
13437 
    iprot.readStructEnd()
13438 
 
13439 
  def write(self, oprot):
13440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13442 
      return
13443 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13444 
    if self.success is not None:
13445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13447 
      for iter317 in self.success:
13448 
        iter317.write(oprot)
4581 phani.kuma 13449 
      oprot.writeListEnd()
13450 
      oprot.writeFieldEnd()
4910 phani.kuma 13451 
    oprot.writeFieldStop()
13452 
    oprot.writeStructEnd()
13453 
 
13454 
  def validate(self):
13455 
    return
13456 
 
13457 
 
13458 
  def __repr__(self):
13459 
    L = ['%s=%r' % (key, value)
13460 
      for key, value in self.__dict__.iteritems()]
13461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13462 
 
13463 
  def __eq__(self, other):
13464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13465 
 
13466 
  def __ne__(self, other):
13467 
    return not (self == other)
13468 
 
13469 
class markOrdersAsDestinationCityReached_args:
13470 
  """
13471 
  Attributes:
13472 
   - providerId
13473 
   - destination_city_reached_orders
13474 
  """
13475 
 
13476 
  thrift_spec = (
13477 
    None, # 0
13478 
    (1, TType.I64, 'providerId', None, None, ), # 1
13479 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13480 
  )
13481 
 
13482 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13483 
    self.providerId = providerId
13484 
    self.destination_city_reached_orders = destination_city_reached_orders
13485 
 
13486 
  def read(self, iprot):
13487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13489 
      return
13490 
    iprot.readStructBegin()
13491 
    while True:
13492 
      (fname, ftype, fid) = iprot.readFieldBegin()
13493 
      if ftype == TType.STOP:
13494 
        break
13495 
      if fid == 1:
13496 
        if ftype == TType.I64:
13497 
          self.providerId = iprot.readI64();
13498 
        else:
13499 
          iprot.skip(ftype)
13500 
      elif fid == 2:
13501 
        if ftype == TType.MAP:
13502 
          self.destination_city_reached_orders = {}
5411 rajveer 13503 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13504 
          for _i322 in xrange(_size318):
13505 
            _key323 = iprot.readString();
13506 
            _val324 = iprot.readString();
13507 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13508 
          iprot.readMapEnd()
13509 
        else:
13510 
          iprot.skip(ftype)
13511 
      else:
13512 
        iprot.skip(ftype)
13513 
      iprot.readFieldEnd()
13514 
    iprot.readStructEnd()
13515 
 
13516 
  def write(self, oprot):
13517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13519 
      return
13520 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13521 
    if self.providerId is not None:
13522 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13523 
      oprot.writeI64(self.providerId)
13524 
      oprot.writeFieldEnd()
13525 
    if self.destination_city_reached_orders is not None:
13526 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13527 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13528 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13529 
        oprot.writeString(kiter325)
13530 
        oprot.writeString(viter326)
4910 phani.kuma 13531 
      oprot.writeMapEnd()
13532 
      oprot.writeFieldEnd()
13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
13551 
class markOrdersAsDestinationCityReached_result:
13552 
  """
13553 
  Attributes:
13554 
   - ex
13555 
  """
13556 
 
13557 
  thrift_spec = (
13558 
    None, # 0
13559 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13560 
  )
13561 
 
13562 
  def __init__(self, ex=None,):
13563 
    self.ex = ex
13564 
 
13565 
  def read(self, iprot):
13566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13568 
      return
13569 
    iprot.readStructBegin()
13570 
    while True:
13571 
      (fname, ftype, fid) = iprot.readFieldBegin()
13572 
      if ftype == TType.STOP:
13573 
        break
13574 
      if fid == 1:
13575 
        if ftype == TType.STRUCT:
13576 
          self.ex = TransactionServiceException()
13577 
          self.ex.read(iprot)
13578 
        else:
13579 
          iprot.skip(ftype)
13580 
      else:
13581 
        iprot.skip(ftype)
13582 
      iprot.readFieldEnd()
13583 
    iprot.readStructEnd()
13584 
 
13585 
  def write(self, oprot):
13586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13588 
      return
13589 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13590 
    if self.ex is not None:
3064 chandransh 13591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13592 
      self.ex.write(oprot)
1627 ankur.sing 13593 
      oprot.writeFieldEnd()
13594 
    oprot.writeFieldStop()
13595 
    oprot.writeStructEnd()
13596 
 
3431 rajveer 13597 
  def validate(self):
13598 
    return
13599 
 
13600 
 
1627 ankur.sing 13601 
  def __repr__(self):
13602 
    L = ['%s=%r' % (key, value)
13603 
      for key, value in self.__dict__.iteritems()]
13604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13605 
 
13606 
  def __eq__(self, other):
13607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13608 
 
13609 
  def __ne__(self, other):
13610 
    return not (self == other)
13611 
 
4910 phani.kuma 13612 
class markOrdersAsFirstDeliveryAttempted_args:
13613 
  """
13614 
  Attributes:
13615 
   - providerId
13616 
   - first_atdl_orders
13617 
  """
13618 
 
13619 
  thrift_spec = (
13620 
    None, # 0
13621 
    (1, TType.I64, 'providerId', None, None, ), # 1
13622 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13623 
  )
13624 
 
13625 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13626 
    self.providerId = providerId
13627 
    self.first_atdl_orders = first_atdl_orders
13628 
 
13629 
  def read(self, iprot):
13630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13632 
      return
13633 
    iprot.readStructBegin()
13634 
    while True:
13635 
      (fname, ftype, fid) = iprot.readFieldBegin()
13636 
      if ftype == TType.STOP:
13637 
        break
13638 
      if fid == 1:
13639 
        if ftype == TType.I64:
13640 
          self.providerId = iprot.readI64();
13641 
        else:
13642 
          iprot.skip(ftype)
13643 
      elif fid == 2:
13644 
        if ftype == TType.MAP:
13645 
          self.first_atdl_orders = {}
5411 rajveer 13646 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
13647 
          for _i331 in xrange(_size327):
13648 
            _key332 = iprot.readString();
13649 
            _val333 = iprot.readString();
13650 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 13651 
          iprot.readMapEnd()
13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      else:
13655 
        iprot.skip(ftype)
13656 
      iprot.readFieldEnd()
13657 
    iprot.readStructEnd()
13658 
 
13659 
  def write(self, oprot):
13660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13662 
      return
13663 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13664 
    if self.providerId is not None:
13665 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13666 
      oprot.writeI64(self.providerId)
13667 
      oprot.writeFieldEnd()
13668 
    if self.first_atdl_orders is not None:
13669 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13670 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 13671 
      for kiter334,viter335 in self.first_atdl_orders.items():
13672 
        oprot.writeString(kiter334)
13673 
        oprot.writeString(viter335)
4910 phani.kuma 13674 
      oprot.writeMapEnd()
13675 
      oprot.writeFieldEnd()
13676 
    oprot.writeFieldStop()
13677 
    oprot.writeStructEnd()
13678 
 
13679 
  def validate(self):
13680 
    return
13681 
 
13682 
 
13683 
  def __repr__(self):
13684 
    L = ['%s=%r' % (key, value)
13685 
      for key, value in self.__dict__.iteritems()]
13686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13687 
 
13688 
  def __eq__(self, other):
13689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13690 
 
13691 
  def __ne__(self, other):
13692 
    return not (self == other)
13693 
 
13694 
class markOrdersAsFirstDeliveryAttempted_result:
13695 
  """
13696 
  Attributes:
13697 
   - ex
13698 
  """
13699 
 
13700 
  thrift_spec = (
13701 
    None, # 0
13702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13703 
  )
13704 
 
13705 
  def __init__(self, ex=None,):
13706 
    self.ex = ex
13707 
 
13708 
  def read(self, iprot):
13709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13711 
      return
13712 
    iprot.readStructBegin()
13713 
    while True:
13714 
      (fname, ftype, fid) = iprot.readFieldBegin()
13715 
      if ftype == TType.STOP:
13716 
        break
13717 
      if fid == 1:
13718 
        if ftype == TType.STRUCT:
13719 
          self.ex = TransactionServiceException()
13720 
          self.ex.read(iprot)
13721 
        else:
13722 
          iprot.skip(ftype)
13723 
      else:
13724 
        iprot.skip(ftype)
13725 
      iprot.readFieldEnd()
13726 
    iprot.readStructEnd()
13727 
 
13728 
  def write(self, oprot):
13729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13731 
      return
13732 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13733 
    if self.ex is not None:
13734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13735 
      self.ex.write(oprot)
13736 
      oprot.writeFieldEnd()
13737 
    oprot.writeFieldStop()
13738 
    oprot.writeStructEnd()
13739 
 
13740 
  def validate(self):
13741 
    return
13742 
 
13743 
 
13744 
  def __repr__(self):
13745 
    L = ['%s=%r' % (key, value)
13746 
      for key, value in self.__dict__.iteritems()]
13747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13748 
 
13749 
  def __eq__(self, other):
13750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13751 
 
13752 
  def __ne__(self, other):
13753 
    return not (self == other)
13754 
 
3064 chandransh 13755 
class getUndeliveredOrders_args:
1886 ankur.sing 13756 
  """
13757 
  Attributes:
3064 chandransh 13758 
   - providerId
13759 
   - warehouseId
1886 ankur.sing 13760 
  """
1627 ankur.sing 13761 
 
1886 ankur.sing 13762 
  thrift_spec = (
13763 
    None, # 0
3064 chandransh 13764 
    (1, TType.I64, 'providerId', None, None, ), # 1
13765 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13766 
  )
13767 
 
3064 chandransh 13768 
  def __init__(self, providerId=None, warehouseId=None,):
13769 
    self.providerId = providerId
13770 
    self.warehouseId = warehouseId
1886 ankur.sing 13771 
 
13772 
  def read(self, iprot):
13773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13775 
      return
13776 
    iprot.readStructBegin()
13777 
    while True:
13778 
      (fname, ftype, fid) = iprot.readFieldBegin()
13779 
      if ftype == TType.STOP:
13780 
        break
13781 
      if fid == 1:
13782 
        if ftype == TType.I64:
3064 chandransh 13783 
          self.providerId = iprot.readI64();
1886 ankur.sing 13784 
        else:
13785 
          iprot.skip(ftype)
3064 chandransh 13786 
      elif fid == 2:
13787 
        if ftype == TType.I64:
13788 
          self.warehouseId = iprot.readI64();
13789 
        else:
13790 
          iprot.skip(ftype)
1886 ankur.sing 13791 
      else:
13792 
        iprot.skip(ftype)
13793 
      iprot.readFieldEnd()
13794 
    iprot.readStructEnd()
13795 
 
13796 
  def write(self, oprot):
13797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13799 
      return
3064 chandransh 13800 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13801 
    if self.providerId is not None:
3064 chandransh 13802 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13803 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13804 
      oprot.writeFieldEnd()
3431 rajveer 13805 
    if self.warehouseId is not None:
3064 chandransh 13806 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13807 
      oprot.writeI64(self.warehouseId)
13808 
      oprot.writeFieldEnd()
1886 ankur.sing 13809 
    oprot.writeFieldStop()
13810 
    oprot.writeStructEnd()
13811 
 
3431 rajveer 13812 
  def validate(self):
13813 
    return
13814 
 
13815 
 
1886 ankur.sing 13816 
  def __repr__(self):
13817 
    L = ['%s=%r' % (key, value)
13818 
      for key, value in self.__dict__.iteritems()]
13819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13820 
 
13821 
  def __eq__(self, other):
13822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13823 
 
13824 
  def __ne__(self, other):
13825 
    return not (self == other)
13826 
 
3064 chandransh 13827 
class getUndeliveredOrders_result:
1886 ankur.sing 13828 
  """
13829 
  Attributes:
13830 
   - success
13831 
  """
13832 
 
13833 
  thrift_spec = (
13834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13835 
  )
13836 
 
13837 
  def __init__(self, success=None,):
13838 
    self.success = success
13839 
 
13840 
  def read(self, iprot):
13841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13843 
      return
13844 
    iprot.readStructBegin()
13845 
    while True:
13846 
      (fname, ftype, fid) = iprot.readFieldBegin()
13847 
      if ftype == TType.STOP:
13848 
        break
13849 
      if fid == 0:
13850 
        if ftype == TType.LIST:
13851 
          self.success = []
5411 rajveer 13852 
          (_etype339, _size336) = iprot.readListBegin()
13853 
          for _i340 in xrange(_size336):
13854 
            _elem341 = Order()
13855 
            _elem341.read(iprot)
13856 
            self.success.append(_elem341)
1886 ankur.sing 13857 
          iprot.readListEnd()
13858 
        else:
13859 
          iprot.skip(ftype)
13860 
      else:
13861 
        iprot.skip(ftype)
13862 
      iprot.readFieldEnd()
13863 
    iprot.readStructEnd()
13864 
 
13865 
  def write(self, oprot):
13866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13868 
      return
3064 chandransh 13869 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13870 
    if self.success is not None:
1886 ankur.sing 13871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13873 
      for iter342 in self.success:
13874 
        iter342.write(oprot)
1886 ankur.sing 13875 
      oprot.writeListEnd()
13876 
      oprot.writeFieldEnd()
13877 
    oprot.writeFieldStop()
13878 
    oprot.writeStructEnd()
13879 
 
3431 rajveer 13880 
  def validate(self):
13881 
    return
13882 
 
13883 
 
1886 ankur.sing 13884 
  def __repr__(self):
13885 
    L = ['%s=%r' % (key, value)
13886 
      for key, value in self.__dict__.iteritems()]
13887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13888 
 
13889 
  def __eq__(self, other):
13890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13891 
 
13892 
  def __ne__(self, other):
13893 
    return not (self == other)
13894 
 
4783 phani.kuma 13895 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13896 
 
13897 
  thrift_spec = (
13898 
  )
13899 
 
13900 
  def read(self, iprot):
13901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13903 
      return
13904 
    iprot.readStructBegin()
13905 
    while True:
13906 
      (fname, ftype, fid) = iprot.readFieldBegin()
13907 
      if ftype == TType.STOP:
13908 
        break
13909 
      else:
13910 
        iprot.skip(ftype)
13911 
      iprot.readFieldEnd()
13912 
    iprot.readStructEnd()
13913 
 
13914 
  def write(self, oprot):
13915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13917 
      return
13918 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13919 
    oprot.writeFieldStop()
13920 
    oprot.writeStructEnd()
13921 
 
13922 
  def validate(self):
13923 
    return
13924 
 
13925 
 
13926 
  def __repr__(self):
13927 
    L = ['%s=%r' % (key, value)
13928 
      for key, value in self.__dict__.iteritems()]
13929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13930 
 
13931 
  def __eq__(self, other):
13932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13933 
 
13934 
  def __ne__(self, other):
13935 
    return not (self == other)
13936 
 
13937 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13938 
  """
13939 
  Attributes:
13940 
   - success
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13945 
  )
13946 
 
13947 
  def __init__(self, success=None,):
13948 
    self.success = success
13949 
 
13950 
  def read(self, iprot):
13951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13953 
      return
13954 
    iprot.readStructBegin()
13955 
    while True:
13956 
      (fname, ftype, fid) = iprot.readFieldBegin()
13957 
      if ftype == TType.STOP:
13958 
        break
13959 
      if fid == 0:
13960 
        if ftype == TType.LIST:
13961 
          self.success = []
5411 rajveer 13962 
          (_etype346, _size343) = iprot.readListBegin()
13963 
          for _i347 in xrange(_size343):
13964 
            _elem348 = Order()
13965 
            _elem348.read(iprot)
13966 
            self.success.append(_elem348)
4783 phani.kuma 13967 
          iprot.readListEnd()
13968 
        else:
13969 
          iprot.skip(ftype)
13970 
      else:
13971 
        iprot.skip(ftype)
13972 
      iprot.readFieldEnd()
13973 
    iprot.readStructEnd()
13974 
 
13975 
  def write(self, oprot):
13976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13978 
      return
13979 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13980 
    if self.success is not None:
13981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13983 
      for iter349 in self.success:
13984 
        iter349.write(oprot)
4783 phani.kuma 13985 
      oprot.writeListEnd()
13986 
      oprot.writeFieldEnd()
13987 
    oprot.writeFieldStop()
13988 
    oprot.writeStructEnd()
13989 
 
13990 
  def validate(self):
13991 
    return
13992 
 
13993 
 
13994 
  def __repr__(self):
13995 
    L = ['%s=%r' % (key, value)
13996 
      for key, value in self.__dict__.iteritems()]
13997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13998 
 
13999 
  def __eq__(self, other):
14000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14001 
 
14002 
  def __ne__(self, other):
14003 
    return not (self == other)
14004 
 
2536 chandransh 14005 
class toggleDOAFlag_args:
14006 
  """
14007 
  Attributes:
14008 
   - orderId
14009 
  """
1886 ankur.sing 14010 
 
2536 chandransh 14011 
  thrift_spec = (
14012 
    None, # 0
14013 
    (1, TType.I64, 'orderId', None, None, ), # 1
14014 
  )
14015 
 
14016 
  def __init__(self, orderId=None,):
14017 
    self.orderId = orderId
14018 
 
14019 
  def read(self, iprot):
14020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14022 
      return
14023 
    iprot.readStructBegin()
14024 
    while True:
14025 
      (fname, ftype, fid) = iprot.readFieldBegin()
14026 
      if ftype == TType.STOP:
14027 
        break
14028 
      if fid == 1:
14029 
        if ftype == TType.I64:
14030 
          self.orderId = iprot.readI64();
14031 
        else:
14032 
          iprot.skip(ftype)
14033 
      else:
14034 
        iprot.skip(ftype)
14035 
      iprot.readFieldEnd()
14036 
    iprot.readStructEnd()
14037 
 
14038 
  def write(self, oprot):
14039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14041 
      return
14042 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14043 
    if self.orderId is not None:
2536 chandransh 14044 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14045 
      oprot.writeI64(self.orderId)
14046 
      oprot.writeFieldEnd()
14047 
    oprot.writeFieldStop()
14048 
    oprot.writeStructEnd()
14049 
 
3431 rajveer 14050 
  def validate(self):
14051 
    return
14052 
 
14053 
 
2536 chandransh 14054 
  def __repr__(self):
14055 
    L = ['%s=%r' % (key, value)
14056 
      for key, value in self.__dict__.iteritems()]
14057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14058 
 
14059 
  def __eq__(self, other):
14060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14061 
 
14062 
  def __ne__(self, other):
14063 
    return not (self == other)
14064 
 
14065 
class toggleDOAFlag_result:
14066 
  """
14067 
  Attributes:
14068 
   - success
14069 
   - ex
14070 
  """
14071 
 
14072 
  thrift_spec = (
14073 
    (0, TType.BOOL, 'success', None, None, ), # 0
14074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14075 
  )
14076 
 
14077 
  def __init__(self, success=None, ex=None,):
14078 
    self.success = success
14079 
    self.ex = ex
14080 
 
14081 
  def read(self, iprot):
14082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14084 
      return
14085 
    iprot.readStructBegin()
14086 
    while True:
14087 
      (fname, ftype, fid) = iprot.readFieldBegin()
14088 
      if ftype == TType.STOP:
14089 
        break
14090 
      if fid == 0:
14091 
        if ftype == TType.BOOL:
14092 
          self.success = iprot.readBool();
14093 
        else:
14094 
          iprot.skip(ftype)
14095 
      elif fid == 1:
14096 
        if ftype == TType.STRUCT:
14097 
          self.ex = TransactionServiceException()
14098 
          self.ex.read(iprot)
14099 
        else:
14100 
          iprot.skip(ftype)
14101 
      else:
14102 
        iprot.skip(ftype)
14103 
      iprot.readFieldEnd()
14104 
    iprot.readStructEnd()
14105 
 
14106 
  def write(self, oprot):
14107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14109 
      return
14110 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14111 
    if self.success is not None:
2536 chandransh 14112 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14113 
      oprot.writeBool(self.success)
14114 
      oprot.writeFieldEnd()
3431 rajveer 14115 
    if self.ex is not None:
2536 chandransh 14116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14117 
      self.ex.write(oprot)
14118 
      oprot.writeFieldEnd()
14119 
    oprot.writeFieldStop()
14120 
    oprot.writeStructEnd()
14121 
 
3431 rajveer 14122 
  def validate(self):
14123 
    return
14124 
 
14125 
 
2536 chandransh 14126 
  def __repr__(self):
14127 
    L = ['%s=%r' % (key, value)
14128 
      for key, value in self.__dict__.iteritems()]
14129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14130 
 
14131 
  def __eq__(self, other):
14132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14133 
 
14134 
  def __ne__(self, other):
14135 
    return not (self == other)
14136 
 
4712 rajveer 14137 
class markOrderAsDelivered_args:
14138 
  """
14139 
  Attributes:
14140 
   - orderId
14141 
   - deliveryTimestamp
14142 
   - receiver
14143 
  """
14144 
 
14145 
  thrift_spec = None
14146 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14147 
    self.orderId = orderId
14148 
    self.deliveryTimestamp = deliveryTimestamp
14149 
    self.receiver = receiver
14150 
 
14151 
  def read(self, iprot):
14152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14154 
      return
14155 
    iprot.readStructBegin()
14156 
    while True:
14157 
      (fname, ftype, fid) = iprot.readFieldBegin()
14158 
      if ftype == TType.STOP:
14159 
        break
14160 
      if fid == 1:
14161 
        if ftype == TType.I64:
14162 
          self.orderId = iprot.readI64();
14163 
        else:
14164 
          iprot.skip(ftype)
14165 
      elif fid == 2:
14166 
        if ftype == TType.I64:
14167 
          self.deliveryTimestamp = iprot.readI64();
14168 
        else:
14169 
          iprot.skip(ftype)
14170 
      elif fid == -1:
14171 
        if ftype == TType.STRING:
14172 
          self.receiver = iprot.readString();
14173 
        else:
14174 
          iprot.skip(ftype)
14175 
      else:
14176 
        iprot.skip(ftype)
14177 
      iprot.readFieldEnd()
14178 
    iprot.readStructEnd()
14179 
 
14180 
  def write(self, oprot):
14181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14183 
      return
14184 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14185 
    if self.receiver is not None:
14186 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14187 
      oprot.writeString(self.receiver)
14188 
      oprot.writeFieldEnd()
14189 
    if self.orderId is not None:
14190 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14191 
      oprot.writeI64(self.orderId)
14192 
      oprot.writeFieldEnd()
14193 
    if self.deliveryTimestamp is not None:
14194 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14195 
      oprot.writeI64(self.deliveryTimestamp)
14196 
      oprot.writeFieldEnd()
14197 
    oprot.writeFieldStop()
14198 
    oprot.writeStructEnd()
14199 
 
14200 
  def validate(self):
14201 
    return
14202 
 
14203 
 
14204 
  def __repr__(self):
14205 
    L = ['%s=%r' % (key, value)
14206 
      for key, value in self.__dict__.iteritems()]
14207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14208 
 
14209 
  def __eq__(self, other):
14210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14211 
 
14212 
  def __ne__(self, other):
14213 
    return not (self == other)
14214 
 
14215 
class markOrderAsDelivered_result:
14216 
  """
14217 
  Attributes:
14218 
   - ex
14219 
  """
14220 
 
14221 
  thrift_spec = (
14222 
    None, # 0
14223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14224 
  )
14225 
 
14226 
  def __init__(self, ex=None,):
14227 
    self.ex = ex
14228 
 
14229 
  def read(self, iprot):
14230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14232 
      return
14233 
    iprot.readStructBegin()
14234 
    while True:
14235 
      (fname, ftype, fid) = iprot.readFieldBegin()
14236 
      if ftype == TType.STOP:
14237 
        break
14238 
      if fid == 1:
14239 
        if ftype == TType.STRUCT:
14240 
          self.ex = TransactionServiceException()
14241 
          self.ex.read(iprot)
14242 
        else:
14243 
          iprot.skip(ftype)
14244 
      else:
14245 
        iprot.skip(ftype)
14246 
      iprot.readFieldEnd()
14247 
    iprot.readStructEnd()
14248 
 
14249 
  def write(self, oprot):
14250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14252 
      return
14253 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14254 
    if self.ex is not None:
14255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14256 
      self.ex.write(oprot)
14257 
      oprot.writeFieldEnd()
14258 
    oprot.writeFieldStop()
14259 
    oprot.writeStructEnd()
14260 
 
14261 
  def validate(self):
14262 
    return
14263 
 
14264 
 
14265 
  def __repr__(self):
14266 
    L = ['%s=%r' % (key, value)
14267 
      for key, value in self.__dict__.iteritems()]
14268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14269 
 
14270 
  def __eq__(self, other):
14271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14272 
 
14273 
  def __ne__(self, other):
14274 
    return not (self == other)
14275 
 
4454 rajveer 14276 
class markOrderDoaRequestReceived_args:
14277 
  """
14278 
  Attributes:
14279 
   - orderId
14280 
  """
14281 
 
14282 
  thrift_spec = (
14283 
    None, # 0
14284 
    (1, TType.I64, 'orderId', None, None, ), # 1
14285 
  )
14286 
 
14287 
  def __init__(self, orderId=None,):
14288 
    self.orderId = orderId
14289 
 
14290 
  def read(self, iprot):
14291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14293 
      return
14294 
    iprot.readStructBegin()
14295 
    while True:
14296 
      (fname, ftype, fid) = iprot.readFieldBegin()
14297 
      if ftype == TType.STOP:
14298 
        break
14299 
      if fid == 1:
14300 
        if ftype == TType.I64:
14301 
          self.orderId = iprot.readI64();
14302 
        else:
14303 
          iprot.skip(ftype)
14304 
      else:
14305 
        iprot.skip(ftype)
14306 
      iprot.readFieldEnd()
14307 
    iprot.readStructEnd()
14308 
 
14309 
  def write(self, oprot):
14310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14312 
      return
14313 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14314 
    if self.orderId is not None:
14315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14316 
      oprot.writeI64(self.orderId)
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
14335 
 
14336 
class markOrderDoaRequestReceived_result:
14337 
  """
14338 
  Attributes:
14339 
   - success
14340 
   - ex
14341 
  """
14342 
 
14343 
  thrift_spec = (
14344 
    (0, TType.BOOL, 'success', None, None, ), # 0
14345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14346 
  )
14347 
 
14348 
  def __init__(self, success=None, ex=None,):
14349 
    self.success = success
14350 
    self.ex = ex
14351 
 
14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
14361 
      if fid == 0:
14362 
        if ftype == TType.BOOL:
14363 
          self.success = iprot.readBool();
14364 
        else:
14365 
          iprot.skip(ftype)
14366 
      elif fid == 1:
14367 
        if ftype == TType.STRUCT:
14368 
          self.ex = TransactionServiceException()
14369 
          self.ex.read(iprot)
14370 
        else:
14371 
          iprot.skip(ftype)
14372 
      else:
14373 
        iprot.skip(ftype)
14374 
      iprot.readFieldEnd()
14375 
    iprot.readStructEnd()
14376 
 
14377 
  def write(self, oprot):
14378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14380 
      return
14381 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14382 
    if self.success is not None:
14383 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14384 
      oprot.writeBool(self.success)
14385 
      oprot.writeFieldEnd()
14386 
    if self.ex is not None:
14387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14388 
      self.ex.write(oprot)
14389 
      oprot.writeFieldEnd()
14390 
    oprot.writeFieldStop()
14391 
    oprot.writeStructEnd()
14392 
 
14393 
  def validate(self):
14394 
    return
14395 
 
14396 
 
14397 
  def __repr__(self):
14398 
    L = ['%s=%r' % (key, value)
14399 
      for key, value in self.__dict__.iteritems()]
14400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14401 
 
14402 
  def __eq__(self, other):
14403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14404 
 
14405 
  def __ne__(self, other):
14406 
    return not (self == other)
14407 
 
14408 
class markOrderDoaRequestAuthorized_args:
14409 
  """
14410 
  Attributes:
14411 
   - orderId
14412 
   - isAuthorized
14413 
  """
14414 
 
14415 
  thrift_spec = (
14416 
    None, # 0
14417 
    (1, TType.I64, 'orderId', None, None, ), # 1
14418 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14419 
  )
14420 
 
14421 
  def __init__(self, orderId=None, isAuthorized=None,):
14422 
    self.orderId = orderId
14423 
    self.isAuthorized = isAuthorized
14424 
 
14425 
  def read(self, iprot):
14426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14428 
      return
14429 
    iprot.readStructBegin()
14430 
    while True:
14431 
      (fname, ftype, fid) = iprot.readFieldBegin()
14432 
      if ftype == TType.STOP:
14433 
        break
14434 
      if fid == 1:
14435 
        if ftype == TType.I64:
14436 
          self.orderId = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      elif fid == 2:
14440 
        if ftype == TType.BOOL:
14441 
          self.isAuthorized = iprot.readBool();
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      else:
14445 
        iprot.skip(ftype)
14446 
      iprot.readFieldEnd()
14447 
    iprot.readStructEnd()
14448 
 
14449 
  def write(self, oprot):
14450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14452 
      return
14453 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14454 
    if self.orderId is not None:
14455 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14456 
      oprot.writeI64(self.orderId)
14457 
      oprot.writeFieldEnd()
14458 
    if self.isAuthorized is not None:
14459 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14460 
      oprot.writeBool(self.isAuthorized)
14461 
      oprot.writeFieldEnd()
14462 
    oprot.writeFieldStop()
14463 
    oprot.writeStructEnd()
14464 
 
14465 
  def validate(self):
14466 
    return
14467 
 
14468 
 
14469 
  def __repr__(self):
14470 
    L = ['%s=%r' % (key, value)
14471 
      for key, value in self.__dict__.iteritems()]
14472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14473 
 
14474 
  def __eq__(self, other):
14475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14476 
 
14477 
  def __ne__(self, other):
14478 
    return not (self == other)
14479 
 
14480 
class markOrderDoaRequestAuthorized_result:
14481 
  """
14482 
  Attributes:
14483 
   - success
14484 
   - ex
14485 
  """
14486 
 
14487 
  thrift_spec = (
14488 
    (0, TType.BOOL, 'success', None, None, ), # 0
14489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14490 
  )
14491 
 
14492 
  def __init__(self, success=None, ex=None,):
14493 
    self.success = success
14494 
    self.ex = ex
14495 
 
14496 
  def read(self, iprot):
14497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14499 
      return
14500 
    iprot.readStructBegin()
14501 
    while True:
14502 
      (fname, ftype, fid) = iprot.readFieldBegin()
14503 
      if ftype == TType.STOP:
14504 
        break
14505 
      if fid == 0:
14506 
        if ftype == TType.BOOL:
14507 
          self.success = iprot.readBool();
14508 
        else:
14509 
          iprot.skip(ftype)
14510 
      elif fid == 1:
14511 
        if ftype == TType.STRUCT:
14512 
          self.ex = TransactionServiceException()
14513 
          self.ex.read(iprot)
14514 
        else:
14515 
          iprot.skip(ftype)
14516 
      else:
14517 
        iprot.skip(ftype)
14518 
      iprot.readFieldEnd()
14519 
    iprot.readStructEnd()
14520 
 
14521 
  def write(self, oprot):
14522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14524 
      return
14525 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14526 
    if self.success is not None:
14527 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14528 
      oprot.writeBool(self.success)
14529 
      oprot.writeFieldEnd()
14530 
    if self.ex is not None:
14531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14532 
      self.ex.write(oprot)
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
4488 rajveer 14552 
class markOrderReturnRequestReceived_args:
14553 
  """
14554 
  Attributes:
14555 
   - orderId
14556 
  """
14557 
 
14558 
  thrift_spec = (
14559 
    None, # 0
14560 
    (1, TType.I64, 'orderId', None, None, ), # 1
14561 
  )
14562 
 
14563 
  def __init__(self, orderId=None,):
14564 
    self.orderId = orderId
14565 
 
14566 
  def read(self, iprot):
14567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14569 
      return
14570 
    iprot.readStructBegin()
14571 
    while True:
14572 
      (fname, ftype, fid) = iprot.readFieldBegin()
14573 
      if ftype == TType.STOP:
14574 
        break
14575 
      if fid == 1:
14576 
        if ftype == TType.I64:
14577 
          self.orderId = iprot.readI64();
14578 
        else:
14579 
          iprot.skip(ftype)
14580 
      else:
14581 
        iprot.skip(ftype)
14582 
      iprot.readFieldEnd()
14583 
    iprot.readStructEnd()
14584 
 
14585 
  def write(self, oprot):
14586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14588 
      return
14589 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14590 
    if self.orderId is not None:
14591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14592 
      oprot.writeI64(self.orderId)
14593 
      oprot.writeFieldEnd()
14594 
    oprot.writeFieldStop()
14595 
    oprot.writeStructEnd()
14596 
 
14597 
  def validate(self):
14598 
    return
14599 
 
14600 
 
14601 
  def __repr__(self):
14602 
    L = ['%s=%r' % (key, value)
14603 
      for key, value in self.__dict__.iteritems()]
14604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14605 
 
14606 
  def __eq__(self, other):
14607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14608 
 
14609 
  def __ne__(self, other):
14610 
    return not (self == other)
14611 
 
14612 
class markOrderReturnRequestReceived_result:
14613 
  """
14614 
  Attributes:
14615 
   - success
14616 
   - ex
14617 
  """
14618 
 
14619 
  thrift_spec = (
14620 
    (0, TType.BOOL, 'success', None, None, ), # 0
14621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14622 
  )
14623 
 
14624 
  def __init__(self, success=None, ex=None,):
14625 
    self.success = success
14626 
    self.ex = ex
14627 
 
14628 
  def read(self, iprot):
14629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14631 
      return
14632 
    iprot.readStructBegin()
14633 
    while True:
14634 
      (fname, ftype, fid) = iprot.readFieldBegin()
14635 
      if ftype == TType.STOP:
14636 
        break
14637 
      if fid == 0:
14638 
        if ftype == TType.BOOL:
14639 
          self.success = iprot.readBool();
14640 
        else:
14641 
          iprot.skip(ftype)
14642 
      elif fid == 1:
14643 
        if ftype == TType.STRUCT:
14644 
          self.ex = TransactionServiceException()
14645 
          self.ex.read(iprot)
14646 
        else:
14647 
          iprot.skip(ftype)
14648 
      else:
14649 
        iprot.skip(ftype)
14650 
      iprot.readFieldEnd()
14651 
    iprot.readStructEnd()
14652 
 
14653 
  def write(self, oprot):
14654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14656 
      return
14657 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14658 
    if self.success is not None:
14659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14660 
      oprot.writeBool(self.success)
14661 
      oprot.writeFieldEnd()
14662 
    if self.ex is not None:
14663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14664 
      self.ex.write(oprot)
14665 
      oprot.writeFieldEnd()
14666 
    oprot.writeFieldStop()
14667 
    oprot.writeStructEnd()
14668 
 
14669 
  def validate(self):
14670 
    return
14671 
 
14672 
 
14673 
  def __repr__(self):
14674 
    L = ['%s=%r' % (key, value)
14675 
      for key, value in self.__dict__.iteritems()]
14676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14677 
 
14678 
  def __eq__(self, other):
14679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14680 
 
14681 
  def __ne__(self, other):
14682 
    return not (self == other)
14683 
 
14684 
class markOrderReturnRequestAuthorized_args:
14685 
  """
14686 
  Attributes:
14687 
   - orderId
14688 
   - isAuthorized
14689 
  """
14690 
 
14691 
  thrift_spec = (
14692 
    None, # 0
14693 
    (1, TType.I64, 'orderId', None, None, ), # 1
14694 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14695 
  )
14696 
 
14697 
  def __init__(self, orderId=None, isAuthorized=None,):
14698 
    self.orderId = orderId
14699 
    self.isAuthorized = isAuthorized
14700 
 
14701 
  def read(self, iprot):
14702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14704 
      return
14705 
    iprot.readStructBegin()
14706 
    while True:
14707 
      (fname, ftype, fid) = iprot.readFieldBegin()
14708 
      if ftype == TType.STOP:
14709 
        break
14710 
      if fid == 1:
14711 
        if ftype == TType.I64:
14712 
          self.orderId = iprot.readI64();
14713 
        else:
14714 
          iprot.skip(ftype)
14715 
      elif fid == 2:
14716 
        if ftype == TType.BOOL:
14717 
          self.isAuthorized = iprot.readBool();
14718 
        else:
14719 
          iprot.skip(ftype)
14720 
      else:
14721 
        iprot.skip(ftype)
14722 
      iprot.readFieldEnd()
14723 
    iprot.readStructEnd()
14724 
 
14725 
  def write(self, oprot):
14726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14728 
      return
14729 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14730 
    if self.orderId is not None:
14731 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14732 
      oprot.writeI64(self.orderId)
14733 
      oprot.writeFieldEnd()
14734 
    if self.isAuthorized is not None:
14735 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14736 
      oprot.writeBool(self.isAuthorized)
14737 
      oprot.writeFieldEnd()
14738 
    oprot.writeFieldStop()
14739 
    oprot.writeStructEnd()
14740 
 
14741 
  def validate(self):
14742 
    return
14743 
 
14744 
 
14745 
  def __repr__(self):
14746 
    L = ['%s=%r' % (key, value)
14747 
      for key, value in self.__dict__.iteritems()]
14748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14749 
 
14750 
  def __eq__(self, other):
14751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14752 
 
14753 
  def __ne__(self, other):
14754 
    return not (self == other)
14755 
 
14756 
class markOrderReturnRequestAuthorized_result:
14757 
  """
14758 
  Attributes:
14759 
   - success
14760 
   - ex
14761 
  """
14762 
 
14763 
  thrift_spec = (
14764 
    (0, TType.BOOL, 'success', None, None, ), # 0
14765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14766 
  )
14767 
 
14768 
  def __init__(self, success=None, ex=None,):
14769 
    self.success = success
14770 
    self.ex = ex
14771 
 
14772 
  def read(self, iprot):
14773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14775 
      return
14776 
    iprot.readStructBegin()
14777 
    while True:
14778 
      (fname, ftype, fid) = iprot.readFieldBegin()
14779 
      if ftype == TType.STOP:
14780 
        break
14781 
      if fid == 0:
14782 
        if ftype == TType.BOOL:
14783 
          self.success = iprot.readBool();
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      elif fid == 1:
14787 
        if ftype == TType.STRUCT:
14788 
          self.ex = TransactionServiceException()
14789 
          self.ex.read(iprot)
14790 
        else:
14791 
          iprot.skip(ftype)
14792 
      else:
14793 
        iprot.skip(ftype)
14794 
      iprot.readFieldEnd()
14795 
    iprot.readStructEnd()
14796 
 
14797 
  def write(self, oprot):
14798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14800 
      return
14801 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14802 
    if self.success is not None:
14803 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14804 
      oprot.writeBool(self.success)
14805 
      oprot.writeFieldEnd()
14806 
    if self.ex is not None:
14807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14808 
      self.ex.write(oprot)
14809 
      oprot.writeFieldEnd()
14810 
    oprot.writeFieldStop()
14811 
    oprot.writeStructEnd()
14812 
 
14813 
  def validate(self):
14814 
    return
14815 
 
14816 
 
14817 
  def __repr__(self):
14818 
    L = ['%s=%r' % (key, value)
14819 
      for key, value in self.__dict__.iteritems()]
14820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14821 
 
14822 
  def __eq__(self, other):
14823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14824 
 
14825 
  def __ne__(self, other):
14826 
    return not (self == other)
14827 
 
2536 chandransh 14828 
class requestPickupNumber_args:
14829 
  """
14830 
  Attributes:
14831 
   - orderId
4579 rajveer 14832 
   - providerId
2536 chandransh 14833 
  """
14834 
 
14835 
  thrift_spec = (
14836 
    None, # 0
14837 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14838 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14839 
  )
14840 
 
4579 rajveer 14841 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14842 
    self.orderId = orderId
4579 rajveer 14843 
    self.providerId = providerId
2536 chandransh 14844 
 
14845 
  def read(self, iprot):
14846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14848 
      return
14849 
    iprot.readStructBegin()
14850 
    while True:
14851 
      (fname, ftype, fid) = iprot.readFieldBegin()
14852 
      if ftype == TType.STOP:
14853 
        break
14854 
      if fid == 1:
14855 
        if ftype == TType.I64:
14856 
          self.orderId = iprot.readI64();
14857 
        else:
14858 
          iprot.skip(ftype)
4579 rajveer 14859 
      elif fid == 2:
14860 
        if ftype == TType.I64:
14861 
          self.providerId = iprot.readI64();
14862 
        else:
14863 
          iprot.skip(ftype)
2536 chandransh 14864 
      else:
14865 
        iprot.skip(ftype)
14866 
      iprot.readFieldEnd()
14867 
    iprot.readStructEnd()
14868 
 
14869 
  def write(self, oprot):
14870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14872 
      return
14873 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14874 
    if self.orderId is not None:
2536 chandransh 14875 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14876 
      oprot.writeI64(self.orderId)
14877 
      oprot.writeFieldEnd()
4579 rajveer 14878 
    if self.providerId is not None:
14879 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14880 
      oprot.writeI64(self.providerId)
14881 
      oprot.writeFieldEnd()
2536 chandransh 14882 
    oprot.writeFieldStop()
14883 
    oprot.writeStructEnd()
14884 
 
3431 rajveer 14885 
  def validate(self):
14886 
    return
14887 
 
14888 
 
2536 chandransh 14889 
  def __repr__(self):
14890 
    L = ['%s=%r' % (key, value)
14891 
      for key, value in self.__dict__.iteritems()]
14892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14893 
 
14894 
  def __eq__(self, other):
14895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14896 
 
14897 
  def __ne__(self, other):
14898 
    return not (self == other)
14899 
 
14900 
class requestPickupNumber_result:
14901 
  """
14902 
  Attributes:
14903 
   - success
14904 
   - ex
14905 
  """
14906 
 
14907 
  thrift_spec = (
14908 
    (0, TType.BOOL, 'success', None, None, ), # 0
14909 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14910 
  )
14911 
 
14912 
  def __init__(self, success=None, ex=None,):
14913 
    self.success = success
14914 
    self.ex = ex
14915 
 
14916 
  def read(self, iprot):
14917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14919 
      return
14920 
    iprot.readStructBegin()
14921 
    while True:
14922 
      (fname, ftype, fid) = iprot.readFieldBegin()
14923 
      if ftype == TType.STOP:
14924 
        break
14925 
      if fid == 0:
14926 
        if ftype == TType.BOOL:
14927 
          self.success = iprot.readBool();
14928 
        else:
14929 
          iprot.skip(ftype)
14930 
      elif fid == 1:
14931 
        if ftype == TType.STRUCT:
14932 
          self.ex = TransactionServiceException()
14933 
          self.ex.read(iprot)
14934 
        else:
14935 
          iprot.skip(ftype)
14936 
      else:
14937 
        iprot.skip(ftype)
14938 
      iprot.readFieldEnd()
14939 
    iprot.readStructEnd()
14940 
 
14941 
  def write(self, oprot):
14942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14944 
      return
14945 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14946 
    if self.success is not None:
2536 chandransh 14947 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14948 
      oprot.writeBool(self.success)
14949 
      oprot.writeFieldEnd()
3431 rajveer 14950 
    if self.ex is not None:
2536 chandransh 14951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14952 
      self.ex.write(oprot)
14953 
      oprot.writeFieldEnd()
14954 
    oprot.writeFieldStop()
14955 
    oprot.writeStructEnd()
14956 
 
3431 rajveer 14957 
  def validate(self):
14958 
    return
14959 
 
14960 
 
2536 chandransh 14961 
  def __repr__(self):
14962 
    L = ['%s=%r' % (key, value)
14963 
      for key, value in self.__dict__.iteritems()]
14964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14965 
 
14966 
  def __eq__(self, other):
14967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14968 
 
14969 
  def __ne__(self, other):
14970 
    return not (self == other)
14971 
 
14972 
class authorizePickup_args:
14973 
  """
14974 
  Attributes:
14975 
   - orderId
14976 
   - pickupNumber
4602 rajveer 14977 
   - providerId
2536 chandransh 14978 
  """
14979 
 
14980 
  thrift_spec = (
14981 
    None, # 0
14982 
    (1, TType.I64, 'orderId', None, None, ), # 1
14983 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14984 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14985 
  )
14986 
 
4602 rajveer 14987 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14988 
    self.orderId = orderId
14989 
    self.pickupNumber = pickupNumber
4602 rajveer 14990 
    self.providerId = providerId
2536 chandransh 14991 
 
14992 
  def read(self, iprot):
14993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14995 
      return
14996 
    iprot.readStructBegin()
14997 
    while True:
14998 
      (fname, ftype, fid) = iprot.readFieldBegin()
14999 
      if ftype == TType.STOP:
15000 
        break
15001 
      if fid == 1:
15002 
        if ftype == TType.I64:
15003 
          self.orderId = iprot.readI64();
15004 
        else:
15005 
          iprot.skip(ftype)
15006 
      elif fid == 2:
15007 
        if ftype == TType.STRING:
15008 
          self.pickupNumber = iprot.readString();
15009 
        else:
15010 
          iprot.skip(ftype)
4602 rajveer 15011 
      elif fid == 3:
15012 
        if ftype == TType.I64:
15013 
          self.providerId = iprot.readI64();
15014 
        else:
15015 
          iprot.skip(ftype)
2536 chandransh 15016 
      else:
15017 
        iprot.skip(ftype)
15018 
      iprot.readFieldEnd()
15019 
    iprot.readStructEnd()
15020 
 
15021 
  def write(self, oprot):
15022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15024 
      return
15025 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15026 
    if self.orderId is not None:
2536 chandransh 15027 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15028 
      oprot.writeI64(self.orderId)
15029 
      oprot.writeFieldEnd()
3431 rajveer 15030 
    if self.pickupNumber is not None:
2536 chandransh 15031 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15032 
      oprot.writeString(self.pickupNumber)
15033 
      oprot.writeFieldEnd()
4602 rajveer 15034 
    if self.providerId is not None:
15035 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15036 
      oprot.writeI64(self.providerId)
15037 
      oprot.writeFieldEnd()
2536 chandransh 15038 
    oprot.writeFieldStop()
15039 
    oprot.writeStructEnd()
15040 
 
3431 rajveer 15041 
  def validate(self):
15042 
    return
15043 
 
15044 
 
2536 chandransh 15045 
  def __repr__(self):
15046 
    L = ['%s=%r' % (key, value)
15047 
      for key, value in self.__dict__.iteritems()]
15048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15049 
 
15050 
  def __eq__(self, other):
15051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15052 
 
15053 
  def __ne__(self, other):
15054 
    return not (self == other)
15055 
 
15056 
class authorizePickup_result:
15057 
  """
15058 
  Attributes:
15059 
   - success
15060 
   - ex
15061 
  """
15062 
 
15063 
  thrift_spec = (
15064 
    (0, TType.BOOL, 'success', None, None, ), # 0
15065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15066 
  )
15067 
 
15068 
  def __init__(self, success=None, ex=None,):
15069 
    self.success = success
15070 
    self.ex = ex
15071 
 
15072 
  def read(self, iprot):
15073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15075 
      return
15076 
    iprot.readStructBegin()
15077 
    while True:
15078 
      (fname, ftype, fid) = iprot.readFieldBegin()
15079 
      if ftype == TType.STOP:
15080 
        break
15081 
      if fid == 0:
15082 
        if ftype == TType.BOOL:
15083 
          self.success = iprot.readBool();
15084 
        else:
15085 
          iprot.skip(ftype)
15086 
      elif fid == 1:
15087 
        if ftype == TType.STRUCT:
15088 
          self.ex = TransactionServiceException()
15089 
          self.ex.read(iprot)
15090 
        else:
15091 
          iprot.skip(ftype)
15092 
      else:
15093 
        iprot.skip(ftype)
15094 
      iprot.readFieldEnd()
15095 
    iprot.readStructEnd()
15096 
 
15097 
  def write(self, oprot):
15098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15100 
      return
15101 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15102 
    if self.success is not None:
2536 chandransh 15103 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15104 
      oprot.writeBool(self.success)
15105 
      oprot.writeFieldEnd()
3431 rajveer 15106 
    if self.ex is not None:
2536 chandransh 15107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15108 
      self.ex.write(oprot)
15109 
      oprot.writeFieldEnd()
15110 
    oprot.writeFieldStop()
15111 
    oprot.writeStructEnd()
15112 
 
3431 rajveer 15113 
  def validate(self):
15114 
    return
15115 
 
15116 
 
2536 chandransh 15117 
  def __repr__(self):
15118 
    L = ['%s=%r' % (key, value)
15119 
      for key, value in self.__dict__.iteritems()]
15120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15121 
 
15122 
  def __eq__(self, other):
15123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15124 
 
15125 
  def __ne__(self, other):
15126 
    return not (self == other)
15127 
 
2764 chandransh 15128 
class markDoasAsPickedUp_args:
15129 
  """
15130 
  Attributes:
15131 
   - providerId
15132 
   - pickupDetails
15133 
  """
15134 
 
15135 
  thrift_spec = (
15136 
    None, # 0
15137 
    (1, TType.I64, 'providerId', None, None, ), # 1
15138 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15139 
  )
15140 
 
15141 
  def __init__(self, providerId=None, pickupDetails=None,):
15142 
    self.providerId = providerId
15143 
    self.pickupDetails = pickupDetails
15144 
 
15145 
  def read(self, iprot):
15146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15148 
      return
15149 
    iprot.readStructBegin()
15150 
    while True:
15151 
      (fname, ftype, fid) = iprot.readFieldBegin()
15152 
      if ftype == TType.STOP:
15153 
        break
15154 
      if fid == 1:
15155 
        if ftype == TType.I64:
15156 
          self.providerId = iprot.readI64();
15157 
        else:
15158 
          iprot.skip(ftype)
15159 
      elif fid == 2:
15160 
        if ftype == TType.MAP:
15161 
          self.pickupDetails = {}
5411 rajveer 15162 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15163 
          for _i354 in xrange(_size350):
15164 
            _key355 = iprot.readString();
15165 
            _val356 = iprot.readString();
15166 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15167 
          iprot.readMapEnd()
15168 
        else:
15169 
          iprot.skip(ftype)
15170 
      else:
15171 
        iprot.skip(ftype)
15172 
      iprot.readFieldEnd()
15173 
    iprot.readStructEnd()
15174 
 
15175 
  def write(self, oprot):
15176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15178 
      return
15179 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15180 
    if self.providerId is not None:
2764 chandransh 15181 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15182 
      oprot.writeI64(self.providerId)
15183 
      oprot.writeFieldEnd()
3431 rajveer 15184 
    if self.pickupDetails is not None:
2764 chandransh 15185 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15186 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15187 
      for kiter357,viter358 in self.pickupDetails.items():
15188 
        oprot.writeString(kiter357)
15189 
        oprot.writeString(viter358)
2764 chandransh 15190 
      oprot.writeMapEnd()
15191 
      oprot.writeFieldEnd()
15192 
    oprot.writeFieldStop()
15193 
    oprot.writeStructEnd()
15194 
 
3431 rajveer 15195 
  def validate(self):
15196 
    return
15197 
 
15198 
 
2764 chandransh 15199 
  def __repr__(self):
15200 
    L = ['%s=%r' % (key, value)
15201 
      for key, value in self.__dict__.iteritems()]
15202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15203 
 
15204 
  def __eq__(self, other):
15205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15206 
 
15207 
  def __ne__(self, other):
15208 
    return not (self == other)
15209 
 
15210 
class markDoasAsPickedUp_result:
4910 phani.kuma 15211 
 
15212 
  thrift_spec = (
15213 
  )
15214 
 
15215 
  def read(self, iprot):
15216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15218 
      return
15219 
    iprot.readStructBegin()
15220 
    while True:
15221 
      (fname, ftype, fid) = iprot.readFieldBegin()
15222 
      if ftype == TType.STOP:
15223 
        break
15224 
      else:
15225 
        iprot.skip(ftype)
15226 
      iprot.readFieldEnd()
15227 
    iprot.readStructEnd()
15228 
 
15229 
  def write(self, oprot):
15230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15232 
      return
15233 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15234 
    oprot.writeFieldStop()
15235 
    oprot.writeStructEnd()
15236 
 
15237 
  def validate(self):
15238 
    return
15239 
 
15240 
 
15241 
  def __repr__(self):
15242 
    L = ['%s=%r' % (key, value)
15243 
      for key, value in self.__dict__.iteritems()]
15244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15245 
 
15246 
  def __eq__(self, other):
15247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15248 
 
15249 
  def __ne__(self, other):
15250 
    return not (self == other)
15251 
 
15252 
class getDoasNotPickedUp_args:
2764 chandransh 15253 
  """
15254 
  Attributes:
4910 phani.kuma 15255 
   - providerId
15256 
  """
15257 
 
15258 
  thrift_spec = (
15259 
    None, # 0
15260 
    (1, TType.I64, 'providerId', None, None, ), # 1
15261 
  )
15262 
 
15263 
  def __init__(self, providerId=None,):
15264 
    self.providerId = providerId
15265 
 
15266 
  def read(self, iprot):
15267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15269 
      return
15270 
    iprot.readStructBegin()
15271 
    while True:
15272 
      (fname, ftype, fid) = iprot.readFieldBegin()
15273 
      if ftype == TType.STOP:
15274 
        break
15275 
      if fid == 1:
15276 
        if ftype == TType.I64:
15277 
          self.providerId = iprot.readI64();
15278 
        else:
15279 
          iprot.skip(ftype)
15280 
      else:
15281 
        iprot.skip(ftype)
15282 
      iprot.readFieldEnd()
15283 
    iprot.readStructEnd()
15284 
 
15285 
  def write(self, oprot):
15286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15288 
      return
15289 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15290 
    if self.providerId is not None:
15291 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15292 
      oprot.writeI64(self.providerId)
15293 
      oprot.writeFieldEnd()
15294 
    oprot.writeFieldStop()
15295 
    oprot.writeStructEnd()
15296 
 
15297 
  def validate(self):
15298 
    return
15299 
 
15300 
 
15301 
  def __repr__(self):
15302 
    L = ['%s=%r' % (key, value)
15303 
      for key, value in self.__dict__.iteritems()]
15304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15305 
 
15306 
  def __eq__(self, other):
15307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15308 
 
15309 
  def __ne__(self, other):
15310 
    return not (self == other)
15311 
 
15312 
class getDoasNotPickedUp_result:
15313 
  """
15314 
  Attributes:
2764 chandransh 15315 
   - success
15316 
  """
15317 
 
15318 
  thrift_spec = (
15319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15320 
  )
15321 
 
15322 
  def __init__(self, success=None,):
15323 
    self.success = success
15324 
 
15325 
  def read(self, iprot):
15326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15328 
      return
15329 
    iprot.readStructBegin()
15330 
    while True:
15331 
      (fname, ftype, fid) = iprot.readFieldBegin()
15332 
      if ftype == TType.STOP:
15333 
        break
15334 
      if fid == 0:
15335 
        if ftype == TType.LIST:
15336 
          self.success = []
5411 rajveer 15337 
          (_etype362, _size359) = iprot.readListBegin()
15338 
          for _i363 in xrange(_size359):
15339 
            _elem364 = Order()
15340 
            _elem364.read(iprot)
15341 
            self.success.append(_elem364)
2764 chandransh 15342 
          iprot.readListEnd()
15343 
        else:
15344 
          iprot.skip(ftype)
15345 
      else:
15346 
        iprot.skip(ftype)
15347 
      iprot.readFieldEnd()
15348 
    iprot.readStructEnd()
15349 
 
15350 
  def write(self, oprot):
15351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15353 
      return
4910 phani.kuma 15354 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15355 
    if self.success is not None:
2764 chandransh 15356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15358 
      for iter365 in self.success:
15359 
        iter365.write(oprot)
2764 chandransh 15360 
      oprot.writeListEnd()
15361 
      oprot.writeFieldEnd()
15362 
    oprot.writeFieldStop()
15363 
    oprot.writeStructEnd()
15364 
 
3431 rajveer 15365 
  def validate(self):
15366 
    return
15367 
 
15368 
 
2764 chandransh 15369 
  def __repr__(self):
15370 
    L = ['%s=%r' % (key, value)
15371 
      for key, value in self.__dict__.iteritems()]
15372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15373 
 
15374 
  def __eq__(self, other):
15375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15376 
 
15377 
  def __ne__(self, other):
15378 
    return not (self == other)
15379 
 
4741 phani.kuma 15380 
class markReturnOrdersAsPickedUp_args:
15381 
  """
15382 
  Attributes:
15383 
   - providerId
15384 
   - pickupDetails
15385 
  """
15386 
 
15387 
  thrift_spec = (
15388 
    None, # 0
15389 
    (1, TType.I64, 'providerId', None, None, ), # 1
15390 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15391 
  )
15392 
 
15393 
  def __init__(self, providerId=None, pickupDetails=None,):
15394 
    self.providerId = providerId
15395 
    self.pickupDetails = pickupDetails
15396 
 
15397 
  def read(self, iprot):
15398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15400 
      return
15401 
    iprot.readStructBegin()
15402 
    while True:
15403 
      (fname, ftype, fid) = iprot.readFieldBegin()
15404 
      if ftype == TType.STOP:
15405 
        break
15406 
      if fid == 1:
15407 
        if ftype == TType.I64:
15408 
          self.providerId = iprot.readI64();
15409 
        else:
15410 
          iprot.skip(ftype)
15411 
      elif fid == 2:
15412 
        if ftype == TType.MAP:
15413 
          self.pickupDetails = {}
5411 rajveer 15414 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
15415 
          for _i370 in xrange(_size366):
15416 
            _key371 = iprot.readString();
15417 
            _val372 = iprot.readString();
15418 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 15419 
          iprot.readMapEnd()
15420 
        else:
15421 
          iprot.skip(ftype)
15422 
      else:
15423 
        iprot.skip(ftype)
15424 
      iprot.readFieldEnd()
15425 
    iprot.readStructEnd()
15426 
 
15427 
  def write(self, oprot):
15428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15430 
      return
15431 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15432 
    if self.providerId is not None:
15433 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15434 
      oprot.writeI64(self.providerId)
15435 
      oprot.writeFieldEnd()
15436 
    if self.pickupDetails is not None:
15437 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15438 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15439 
      for kiter373,viter374 in self.pickupDetails.items():
15440 
        oprot.writeString(kiter373)
15441 
        oprot.writeString(viter374)
4741 phani.kuma 15442 
      oprot.writeMapEnd()
15443 
      oprot.writeFieldEnd()
15444 
    oprot.writeFieldStop()
15445 
    oprot.writeStructEnd()
15446 
 
15447 
  def validate(self):
15448 
    return
15449 
 
15450 
 
15451 
  def __repr__(self):
15452 
    L = ['%s=%r' % (key, value)
15453 
      for key, value in self.__dict__.iteritems()]
15454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15455 
 
15456 
  def __eq__(self, other):
15457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15458 
 
15459 
  def __ne__(self, other):
15460 
    return not (self == other)
15461 
 
15462 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15463 
 
15464 
  thrift_spec = (
15465 
  )
15466 
 
15467 
  def read(self, iprot):
15468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15470 
      return
15471 
    iprot.readStructBegin()
15472 
    while True:
15473 
      (fname, ftype, fid) = iprot.readFieldBegin()
15474 
      if ftype == TType.STOP:
15475 
        break
15476 
      else:
15477 
        iprot.skip(ftype)
15478 
      iprot.readFieldEnd()
15479 
    iprot.readStructEnd()
15480 
 
15481 
  def write(self, oprot):
15482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15484 
      return
15485 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15486 
    oprot.writeFieldStop()
15487 
    oprot.writeStructEnd()
15488 
 
15489 
  def validate(self):
15490 
    return
15491 
 
15492 
 
15493 
  def __repr__(self):
15494 
    L = ['%s=%r' % (key, value)
15495 
      for key, value in self.__dict__.iteritems()]
15496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15497 
 
15498 
  def __eq__(self, other):
15499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15500 
 
15501 
  def __ne__(self, other):
15502 
    return not (self == other)
15503 
 
15504 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15505 
  """
15506 
  Attributes:
4910 phani.kuma 15507 
   - providerId
15508 
  """
15509 
 
15510 
  thrift_spec = (
15511 
    None, # 0
15512 
    (1, TType.I64, 'providerId', None, None, ), # 1
15513 
  )
15514 
 
15515 
  def __init__(self, providerId=None,):
15516 
    self.providerId = providerId
15517 
 
15518 
  def read(self, iprot):
15519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15521 
      return
15522 
    iprot.readStructBegin()
15523 
    while True:
15524 
      (fname, ftype, fid) = iprot.readFieldBegin()
15525 
      if ftype == TType.STOP:
15526 
        break
15527 
      if fid == 1:
15528 
        if ftype == TType.I64:
15529 
          self.providerId = iprot.readI64();
15530 
        else:
15531 
          iprot.skip(ftype)
15532 
      else:
15533 
        iprot.skip(ftype)
15534 
      iprot.readFieldEnd()
15535 
    iprot.readStructEnd()
15536 
 
15537 
  def write(self, oprot):
15538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15540 
      return
15541 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15542 
    if self.providerId is not None:
15543 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15544 
      oprot.writeI64(self.providerId)
15545 
      oprot.writeFieldEnd()
15546 
    oprot.writeFieldStop()
15547 
    oprot.writeStructEnd()
15548 
 
15549 
  def validate(self):
15550 
    return
15551 
 
15552 
 
15553 
  def __repr__(self):
15554 
    L = ['%s=%r' % (key, value)
15555 
      for key, value in self.__dict__.iteritems()]
15556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15557 
 
15558 
  def __eq__(self, other):
15559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15560 
 
15561 
  def __ne__(self, other):
15562 
    return not (self == other)
15563 
 
15564 
class getReturnOrdersNotPickedUp_result:
15565 
  """
15566 
  Attributes:
4741 phani.kuma 15567 
   - success
15568 
  """
15569 
 
15570 
  thrift_spec = (
15571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15572 
  )
15573 
 
15574 
  def __init__(self, success=None,):
15575 
    self.success = success
15576 
 
15577 
  def read(self, iprot):
15578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15580 
      return
15581 
    iprot.readStructBegin()
15582 
    while True:
15583 
      (fname, ftype, fid) = iprot.readFieldBegin()
15584 
      if ftype == TType.STOP:
15585 
        break
15586 
      if fid == 0:
15587 
        if ftype == TType.LIST:
15588 
          self.success = []
5411 rajveer 15589 
          (_etype378, _size375) = iprot.readListBegin()
15590 
          for _i379 in xrange(_size375):
15591 
            _elem380 = Order()
15592 
            _elem380.read(iprot)
15593 
            self.success.append(_elem380)
4741 phani.kuma 15594 
          iprot.readListEnd()
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
4910 phani.kuma 15606 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15607 
    if self.success is not None:
15608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15610 
      for iter381 in self.success:
15611 
        iter381.write(oprot)
4741 phani.kuma 15612 
      oprot.writeListEnd()
15613 
      oprot.writeFieldEnd()
15614 
    oprot.writeFieldStop()
15615 
    oprot.writeStructEnd()
15616 
 
15617 
  def validate(self):
15618 
    return
15619 
 
15620 
 
15621 
  def __repr__(self):
15622 
    L = ['%s=%r' % (key, value)
15623 
      for key, value in self.__dict__.iteritems()]
15624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15625 
 
15626 
  def __eq__(self, other):
15627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15628 
 
15629 
  def __ne__(self, other):
15630 
    return not (self == other)
15631 
 
2616 chandransh 15632 
class receiveReturn_args:
2591 chandransh 15633 
  """
15634 
  Attributes:
15635 
   - orderId
4479 rajveer 15636 
   - receiveCondition
2591 chandransh 15637 
  """
2536 chandransh 15638 
 
2591 chandransh 15639 
  thrift_spec = (
15640 
    None, # 0
15641 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15642 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15643 
  )
15644 
 
4479 rajveer 15645 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15646 
    self.orderId = orderId
4479 rajveer 15647 
    self.receiveCondition = receiveCondition
2591 chandransh 15648 
 
15649 
  def read(self, iprot):
15650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15652 
      return
15653 
    iprot.readStructBegin()
15654 
    while True:
15655 
      (fname, ftype, fid) = iprot.readFieldBegin()
15656 
      if ftype == TType.STOP:
15657 
        break
15658 
      if fid == 1:
15659 
        if ftype == TType.I64:
15660 
          self.orderId = iprot.readI64();
15661 
        else:
15662 
          iprot.skip(ftype)
4479 rajveer 15663 
      elif fid == 2:
15664 
        if ftype == TType.I64:
15665 
          self.receiveCondition = iprot.readI64();
15666 
        else:
15667 
          iprot.skip(ftype)
2591 chandransh 15668 
      else:
15669 
        iprot.skip(ftype)
15670 
      iprot.readFieldEnd()
15671 
    iprot.readStructEnd()
15672 
 
15673 
  def write(self, oprot):
15674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15676 
      return
2616 chandransh 15677 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15678 
    if self.orderId is not None:
2591 chandransh 15679 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15680 
      oprot.writeI64(self.orderId)
15681 
      oprot.writeFieldEnd()
4479 rajveer 15682 
    if self.receiveCondition is not None:
15683 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15684 
      oprot.writeI64(self.receiveCondition)
15685 
      oprot.writeFieldEnd()
2591 chandransh 15686 
    oprot.writeFieldStop()
15687 
    oprot.writeStructEnd()
15688 
 
3431 rajveer 15689 
  def validate(self):
15690 
    return
15691 
 
15692 
 
2591 chandransh 15693 
  def __repr__(self):
15694 
    L = ['%s=%r' % (key, value)
15695 
      for key, value in self.__dict__.iteritems()]
15696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15697 
 
15698 
  def __eq__(self, other):
15699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15700 
 
15701 
  def __ne__(self, other):
15702 
    return not (self == other)
15703 
 
2616 chandransh 15704 
class receiveReturn_result:
2591 chandransh 15705 
  """
15706 
  Attributes:
15707 
   - success
15708 
   - ex
15709 
  """
15710 
 
15711 
  thrift_spec = (
15712 
    (0, TType.BOOL, 'success', None, None, ), # 0
15713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15714 
  )
15715 
 
15716 
  def __init__(self, success=None, ex=None,):
15717 
    self.success = success
15718 
    self.ex = ex
15719 
 
15720 
  def read(self, iprot):
15721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15723 
      return
15724 
    iprot.readStructBegin()
15725 
    while True:
15726 
      (fname, ftype, fid) = iprot.readFieldBegin()
15727 
      if ftype == TType.STOP:
15728 
        break
15729 
      if fid == 0:
15730 
        if ftype == TType.BOOL:
15731 
          self.success = iprot.readBool();
15732 
        else:
15733 
          iprot.skip(ftype)
15734 
      elif fid == 1:
15735 
        if ftype == TType.STRUCT:
15736 
          self.ex = TransactionServiceException()
15737 
          self.ex.read(iprot)
15738 
        else:
15739 
          iprot.skip(ftype)
15740 
      else:
15741 
        iprot.skip(ftype)
15742 
      iprot.readFieldEnd()
15743 
    iprot.readStructEnd()
15744 
 
15745 
  def write(self, oprot):
15746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15748 
      return
2616 chandransh 15749 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15750 
    if self.success is not None:
2591 chandransh 15751 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15752 
      oprot.writeBool(self.success)
15753 
      oprot.writeFieldEnd()
3431 rajveer 15754 
    if self.ex is not None:
2591 chandransh 15755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15756 
      self.ex.write(oprot)
15757 
      oprot.writeFieldEnd()
15758 
    oprot.writeFieldStop()
15759 
    oprot.writeStructEnd()
15760 
 
3431 rajveer 15761 
  def validate(self):
15762 
    return
15763 
 
15764 
 
2591 chandransh 15765 
  def __repr__(self):
15766 
    L = ['%s=%r' % (key, value)
15767 
      for key, value in self.__dict__.iteritems()]
15768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15769 
 
15770 
  def __eq__(self, other):
15771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15772 
 
15773 
  def __ne__(self, other):
15774 
    return not (self == other)
15775 
 
15776 
class validateDoa_args:
15777 
  """
15778 
  Attributes:
15779 
   - orderId
15780 
   - isValid
15781 
  """
15782 
 
15783 
  thrift_spec = (
15784 
    None, # 0
15785 
    (1, TType.I64, 'orderId', None, None, ), # 1
15786 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15787 
  )
15788 
 
15789 
  def __init__(self, orderId=None, isValid=None,):
15790 
    self.orderId = orderId
15791 
    self.isValid = isValid
15792 
 
15793 
  def read(self, iprot):
15794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15796 
      return
15797 
    iprot.readStructBegin()
15798 
    while True:
15799 
      (fname, ftype, fid) = iprot.readFieldBegin()
15800 
      if ftype == TType.STOP:
15801 
        break
15802 
      if fid == 1:
15803 
        if ftype == TType.I64:
15804 
          self.orderId = iprot.readI64();
15805 
        else:
15806 
          iprot.skip(ftype)
15807 
      elif fid == 2:
15808 
        if ftype == TType.BOOL:
15809 
          self.isValid = iprot.readBool();
15810 
        else:
15811 
          iprot.skip(ftype)
15812 
      else:
15813 
        iprot.skip(ftype)
15814 
      iprot.readFieldEnd()
15815 
    iprot.readStructEnd()
15816 
 
15817 
  def write(self, oprot):
15818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15820 
      return
15821 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15822 
    if self.orderId is not None:
2591 chandransh 15823 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15824 
      oprot.writeI64(self.orderId)
15825 
      oprot.writeFieldEnd()
3431 rajveer 15826 
    if self.isValid is not None:
2591 chandransh 15827 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15828 
      oprot.writeBool(self.isValid)
15829 
      oprot.writeFieldEnd()
15830 
    oprot.writeFieldStop()
15831 
    oprot.writeStructEnd()
15832 
 
3431 rajveer 15833 
  def validate(self):
15834 
    return
15835 
 
15836 
 
2591 chandransh 15837 
  def __repr__(self):
15838 
    L = ['%s=%r' % (key, value)
15839 
      for key, value in self.__dict__.iteritems()]
15840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15841 
 
15842 
  def __eq__(self, other):
15843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15844 
 
15845 
  def __ne__(self, other):
15846 
    return not (self == other)
15847 
 
15848 
class validateDoa_result:
15849 
  """
15850 
  Attributes:
15851 
   - success
15852 
   - ex
15853 
  """
15854 
 
15855 
  thrift_spec = (
15856 
    (0, TType.BOOL, 'success', None, None, ), # 0
15857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15858 
  )
15859 
 
15860 
  def __init__(self, success=None, ex=None,):
15861 
    self.success = success
15862 
    self.ex = ex
15863 
 
15864 
  def read(self, iprot):
15865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15867 
      return
15868 
    iprot.readStructBegin()
15869 
    while True:
15870 
      (fname, ftype, fid) = iprot.readFieldBegin()
15871 
      if ftype == TType.STOP:
15872 
        break
15873 
      if fid == 0:
15874 
        if ftype == TType.BOOL:
15875 
          self.success = iprot.readBool();
15876 
        else:
15877 
          iprot.skip(ftype)
15878 
      elif fid == 1:
15879 
        if ftype == TType.STRUCT:
15880 
          self.ex = TransactionServiceException()
15881 
          self.ex.read(iprot)
15882 
        else:
15883 
          iprot.skip(ftype)
15884 
      else:
15885 
        iprot.skip(ftype)
15886 
      iprot.readFieldEnd()
15887 
    iprot.readStructEnd()
15888 
 
15889 
  def write(self, oprot):
15890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15892 
      return
15893 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15894 
    if self.success is not None:
2591 chandransh 15895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15896 
      oprot.writeBool(self.success)
15897 
      oprot.writeFieldEnd()
3431 rajveer 15898 
    if self.ex is not None:
2591 chandransh 15899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15900 
      self.ex.write(oprot)
15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
3431 rajveer 15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
2591 chandransh 15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
4495 rajveer 15920 
class validateReturnProduct_args:
15921 
  """
15922 
  Attributes:
15923 
   - orderId
15924 
   - isUsable
15925 
  """
15926 
 
15927 
  thrift_spec = (
15928 
    None, # 0
15929 
    (1, TType.I64, 'orderId', None, None, ), # 1
15930 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15931 
  )
15932 
 
15933 
  def __init__(self, orderId=None, isUsable=None,):
15934 
    self.orderId = orderId
15935 
    self.isUsable = isUsable
15936 
 
15937 
  def read(self, iprot):
15938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15940 
      return
15941 
    iprot.readStructBegin()
15942 
    while True:
15943 
      (fname, ftype, fid) = iprot.readFieldBegin()
15944 
      if ftype == TType.STOP:
15945 
        break
15946 
      if fid == 1:
15947 
        if ftype == TType.I64:
15948 
          self.orderId = iprot.readI64();
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      elif fid == 2:
15952 
        if ftype == TType.BOOL:
15953 
          self.isUsable = iprot.readBool();
15954 
        else:
15955 
          iprot.skip(ftype)
15956 
      else:
15957 
        iprot.skip(ftype)
15958 
      iprot.readFieldEnd()
15959 
    iprot.readStructEnd()
15960 
 
15961 
  def write(self, oprot):
15962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15964 
      return
15965 
    oprot.writeStructBegin('validateReturnProduct_args')
15966 
    if self.orderId is not None:
15967 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15968 
      oprot.writeI64(self.orderId)
15969 
      oprot.writeFieldEnd()
15970 
    if self.isUsable is not None:
15971 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15972 
      oprot.writeBool(self.isUsable)
15973 
      oprot.writeFieldEnd()
15974 
    oprot.writeFieldStop()
15975 
    oprot.writeStructEnd()
15976 
 
15977 
  def validate(self):
15978 
    return
15979 
 
15980 
 
15981 
  def __repr__(self):
15982 
    L = ['%s=%r' % (key, value)
15983 
      for key, value in self.__dict__.iteritems()]
15984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15985 
 
15986 
  def __eq__(self, other):
15987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15988 
 
15989 
  def __ne__(self, other):
15990 
    return not (self == other)
15991 
 
15992 
class validateReturnProduct_result:
15993 
  """
15994 
  Attributes:
15995 
   - success
15996 
   - ex
15997 
  """
15998 
 
15999 
  thrift_spec = (
16000 
    (0, TType.BOOL, 'success', None, None, ), # 0
16001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16002 
  )
16003 
 
16004 
  def __init__(self, success=None, ex=None,):
16005 
    self.success = success
16006 
    self.ex = ex
16007 
 
16008 
  def read(self, iprot):
16009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16011 
      return
16012 
    iprot.readStructBegin()
16013 
    while True:
16014 
      (fname, ftype, fid) = iprot.readFieldBegin()
16015 
      if ftype == TType.STOP:
16016 
        break
16017 
      if fid == 0:
16018 
        if ftype == TType.BOOL:
16019 
          self.success = iprot.readBool();
16020 
        else:
16021 
          iprot.skip(ftype)
16022 
      elif fid == 1:
16023 
        if ftype == TType.STRUCT:
16024 
          self.ex = TransactionServiceException()
16025 
          self.ex.read(iprot)
16026 
        else:
16027 
          iprot.skip(ftype)
16028 
      else:
16029 
        iprot.skip(ftype)
16030 
      iprot.readFieldEnd()
16031 
    iprot.readStructEnd()
16032 
 
16033 
  def write(self, oprot):
16034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16036 
      return
16037 
    oprot.writeStructBegin('validateReturnProduct_result')
16038 
    if self.success is not None:
16039 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16040 
      oprot.writeBool(self.success)
16041 
      oprot.writeFieldEnd()
16042 
    if self.ex is not None:
16043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16044 
      self.ex.write(oprot)
16045 
      oprot.writeFieldEnd()
16046 
    oprot.writeFieldStop()
16047 
    oprot.writeStructEnd()
16048 
 
16049 
  def validate(self):
16050 
    return
16051 
 
16052 
 
16053 
  def __repr__(self):
16054 
    L = ['%s=%r' % (key, value)
16055 
      for key, value in self.__dict__.iteritems()]
16056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16057 
 
16058 
  def __eq__(self, other):
16059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16060 
 
16061 
  def __ne__(self, other):
16062 
    return not (self == other)
16063 
 
2616 chandransh 16064 
class reshipOrder_args:
16065 
  """
16066 
  Attributes:
16067 
   - orderId
16068 
  """
2591 chandransh 16069 
 
2616 chandransh 16070 
  thrift_spec = (
16071 
    None, # 0
16072 
    (1, TType.I64, 'orderId', None, None, ), # 1
16073 
  )
16074 
 
16075 
  def __init__(self, orderId=None,):
16076 
    self.orderId = orderId
16077 
 
16078 
  def read(self, iprot):
16079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16081 
      return
16082 
    iprot.readStructBegin()
16083 
    while True:
16084 
      (fname, ftype, fid) = iprot.readFieldBegin()
16085 
      if ftype == TType.STOP:
16086 
        break
16087 
      if fid == 1:
16088 
        if ftype == TType.I64:
16089 
          self.orderId = iprot.readI64();
16090 
        else:
16091 
          iprot.skip(ftype)
16092 
      else:
16093 
        iprot.skip(ftype)
16094 
      iprot.readFieldEnd()
16095 
    iprot.readStructEnd()
16096 
 
16097 
  def write(self, oprot):
16098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16100 
      return
16101 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16102 
    if self.orderId is not None:
2616 chandransh 16103 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16104 
      oprot.writeI64(self.orderId)
16105 
      oprot.writeFieldEnd()
16106 
    oprot.writeFieldStop()
16107 
    oprot.writeStructEnd()
16108 
 
3431 rajveer 16109 
  def validate(self):
16110 
    return
16111 
 
16112 
 
2616 chandransh 16113 
  def __repr__(self):
16114 
    L = ['%s=%r' % (key, value)
16115 
      for key, value in self.__dict__.iteritems()]
16116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16117 
 
16118 
  def __eq__(self, other):
16119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16120 
 
16121 
  def __ne__(self, other):
16122 
    return not (self == other)
16123 
 
16124 
class reshipOrder_result:
16125 
  """
16126 
  Attributes:
16127 
   - success
16128 
   - ex
16129 
  """
16130 
 
16131 
  thrift_spec = (
16132 
    (0, TType.I64, 'success', None, None, ), # 0
16133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16134 
  )
16135 
 
16136 
  def __init__(self, success=None, ex=None,):
16137 
    self.success = success
16138 
    self.ex = ex
16139 
 
16140 
  def read(self, iprot):
16141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16143 
      return
16144 
    iprot.readStructBegin()
16145 
    while True:
16146 
      (fname, ftype, fid) = iprot.readFieldBegin()
16147 
      if ftype == TType.STOP:
16148 
        break
16149 
      if fid == 0:
16150 
        if ftype == TType.I64:
16151 
          self.success = iprot.readI64();
16152 
        else:
16153 
          iprot.skip(ftype)
16154 
      elif fid == 1:
16155 
        if ftype == TType.STRUCT:
16156 
          self.ex = TransactionServiceException()
16157 
          self.ex.read(iprot)
16158 
        else:
16159 
          iprot.skip(ftype)
16160 
      else:
16161 
        iprot.skip(ftype)
16162 
      iprot.readFieldEnd()
16163 
    iprot.readStructEnd()
16164 
 
16165 
  def write(self, oprot):
16166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16168 
      return
16169 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16170 
    if self.success is not None:
2616 chandransh 16171 
      oprot.writeFieldBegin('success', TType.I64, 0)
16172 
      oprot.writeI64(self.success)
16173 
      oprot.writeFieldEnd()
3431 rajveer 16174 
    if self.ex is not None:
2616 chandransh 16175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16176 
      self.ex.write(oprot)
16177 
      oprot.writeFieldEnd()
16178 
    oprot.writeFieldStop()
16179 
    oprot.writeStructEnd()
16180 
 
3431 rajveer 16181 
  def validate(self):
16182 
    return
16183 
 
16184 
 
2616 chandransh 16185 
  def __repr__(self):
16186 
    L = ['%s=%r' % (key, value)
16187 
      for key, value in self.__dict__.iteritems()]
16188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16189 
 
16190 
  def __eq__(self, other):
16191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16192 
 
16193 
  def __ne__(self, other):
16194 
    return not (self == other)
16195 
 
16196 
class refundOrder_args:
16197 
  """
16198 
  Attributes:
16199 
   - orderId
3226 chandransh 16200 
   - refundedBy
16201 
   - reason
2616 chandransh 16202 
  """
16203 
 
16204 
  thrift_spec = (
16205 
    None, # 0
16206 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16207 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16208 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16209 
  )
16210 
 
3226 chandransh 16211 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16212 
    self.orderId = orderId
3226 chandransh 16213 
    self.refundedBy = refundedBy
16214 
    self.reason = reason
2616 chandransh 16215 
 
16216 
  def read(self, iprot):
16217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16219 
      return
16220 
    iprot.readStructBegin()
16221 
    while True:
16222 
      (fname, ftype, fid) = iprot.readFieldBegin()
16223 
      if ftype == TType.STOP:
16224 
        break
16225 
      if fid == 1:
16226 
        if ftype == TType.I64:
16227 
          self.orderId = iprot.readI64();
16228 
        else:
16229 
          iprot.skip(ftype)
3226 chandransh 16230 
      elif fid == 2:
16231 
        if ftype == TType.STRING:
16232 
          self.refundedBy = iprot.readString();
16233 
        else:
16234 
          iprot.skip(ftype)
16235 
      elif fid == 3:
16236 
        if ftype == TType.STRING:
16237 
          self.reason = iprot.readString();
16238 
        else:
16239 
          iprot.skip(ftype)
2616 chandransh 16240 
      else:
16241 
        iprot.skip(ftype)
16242 
      iprot.readFieldEnd()
16243 
    iprot.readStructEnd()
16244 
 
16245 
  def write(self, oprot):
16246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16248 
      return
16249 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16250 
    if self.orderId is not None:
2616 chandransh 16251 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16252 
      oprot.writeI64(self.orderId)
16253 
      oprot.writeFieldEnd()
3431 rajveer 16254 
    if self.refundedBy is not None:
3226 chandransh 16255 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16256 
      oprot.writeString(self.refundedBy)
16257 
      oprot.writeFieldEnd()
3431 rajveer 16258 
    if self.reason is not None:
3226 chandransh 16259 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16260 
      oprot.writeString(self.reason)
16261 
      oprot.writeFieldEnd()
2616 chandransh 16262 
    oprot.writeFieldStop()
16263 
    oprot.writeStructEnd()
16264 
 
3431 rajveer 16265 
  def validate(self):
16266 
    return
16267 
 
16268 
 
2616 chandransh 16269 
  def __repr__(self):
16270 
    L = ['%s=%r' % (key, value)
16271 
      for key, value in self.__dict__.iteritems()]
16272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16273 
 
16274 
  def __eq__(self, other):
16275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16276 
 
16277 
  def __ne__(self, other):
16278 
    return not (self == other)
16279 
 
16280 
class refundOrder_result:
16281 
  """
16282 
  Attributes:
16283 
   - success
16284 
   - ex
16285 
  """
16286 
 
16287 
  thrift_spec = (
16288 
    (0, TType.BOOL, 'success', None, None, ), # 0
16289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16290 
  )
16291 
 
16292 
  def __init__(self, success=None, ex=None,):
16293 
    self.success = success
16294 
    self.ex = ex
16295 
 
16296 
  def read(self, iprot):
16297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16299 
      return
16300 
    iprot.readStructBegin()
16301 
    while True:
16302 
      (fname, ftype, fid) = iprot.readFieldBegin()
16303 
      if ftype == TType.STOP:
16304 
        break
16305 
      if fid == 0:
16306 
        if ftype == TType.BOOL:
16307 
          self.success = iprot.readBool();
16308 
        else:
16309 
          iprot.skip(ftype)
16310 
      elif fid == 1:
16311 
        if ftype == TType.STRUCT:
16312 
          self.ex = TransactionServiceException()
16313 
          self.ex.read(iprot)
16314 
        else:
16315 
          iprot.skip(ftype)
16316 
      else:
16317 
        iprot.skip(ftype)
16318 
      iprot.readFieldEnd()
16319 
    iprot.readStructEnd()
16320 
 
16321 
  def write(self, oprot):
16322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16324 
      return
16325 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16326 
    if self.success is not None:
2616 chandransh 16327 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16328 
      oprot.writeBool(self.success)
16329 
      oprot.writeFieldEnd()
3431 rajveer 16330 
    if self.ex is not None:
2616 chandransh 16331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16332 
      self.ex.write(oprot)
16333 
      oprot.writeFieldEnd()
16334 
    oprot.writeFieldStop()
16335 
    oprot.writeStructEnd()
16336 
 
3431 rajveer 16337 
  def validate(self):
16338 
    return
16339 
 
16340 
 
2616 chandransh 16341 
  def __repr__(self):
16342 
    L = ['%s=%r' % (key, value)
16343 
      for key, value in self.__dict__.iteritems()]
16344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16345 
 
16346 
  def __eq__(self, other):
16347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16348 
 
16349 
  def __ne__(self, other):
16350 
    return not (self == other)
16351 
 
2690 chandransh 16352 
class getReturnOrders_args:
16353 
  """
16354 
  Attributes:
16355 
   - warehouseId
16356 
   - fromDate
16357 
   - toDate
16358 
  """
2616 chandransh 16359 
 
2690 chandransh 16360 
  thrift_spec = (
16361 
    None, # 0
16362 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16363 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16364 
    (3, TType.I64, 'toDate', None, None, ), # 3
16365 
  )
16366 
 
16367 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16368 
    self.warehouseId = warehouseId
16369 
    self.fromDate = fromDate
16370 
    self.toDate = toDate
16371 
 
16372 
  def read(self, iprot):
16373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16375 
      return
16376 
    iprot.readStructBegin()
16377 
    while True:
16378 
      (fname, ftype, fid) = iprot.readFieldBegin()
16379 
      if ftype == TType.STOP:
16380 
        break
16381 
      if fid == 1:
16382 
        if ftype == TType.I64:
16383 
          self.warehouseId = iprot.readI64();
16384 
        else:
16385 
          iprot.skip(ftype)
16386 
      elif fid == 2:
16387 
        if ftype == TType.I64:
16388 
          self.fromDate = iprot.readI64();
16389 
        else:
16390 
          iprot.skip(ftype)
16391 
      elif fid == 3:
16392 
        if ftype == TType.I64:
16393 
          self.toDate = iprot.readI64();
16394 
        else:
16395 
          iprot.skip(ftype)
16396 
      else:
16397 
        iprot.skip(ftype)
16398 
      iprot.readFieldEnd()
16399 
    iprot.readStructEnd()
16400 
 
16401 
  def write(self, oprot):
16402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16404 
      return
16405 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16406 
    if self.warehouseId is not None:
2690 chandransh 16407 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16408 
      oprot.writeI64(self.warehouseId)
16409 
      oprot.writeFieldEnd()
3431 rajveer 16410 
    if self.fromDate is not None:
2690 chandransh 16411 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16412 
      oprot.writeI64(self.fromDate)
16413 
      oprot.writeFieldEnd()
3431 rajveer 16414 
    if self.toDate is not None:
2690 chandransh 16415 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16416 
      oprot.writeI64(self.toDate)
16417 
      oprot.writeFieldEnd()
16418 
    oprot.writeFieldStop()
16419 
    oprot.writeStructEnd()
16420 
 
3431 rajveer 16421 
  def validate(self):
16422 
    return
16423 
 
16424 
 
2690 chandransh 16425 
  def __repr__(self):
16426 
    L = ['%s=%r' % (key, value)
16427 
      for key, value in self.__dict__.iteritems()]
16428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16429 
 
16430 
  def __eq__(self, other):
16431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16432 
 
16433 
  def __ne__(self, other):
16434 
    return not (self == other)
16435 
 
16436 
class getReturnOrders_result:
16437 
  """
16438 
  Attributes:
16439 
   - success
16440 
  """
16441 
 
16442 
  thrift_spec = (
16443 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16444 
  )
16445 
 
16446 
  def __init__(self, success=None,):
16447 
    self.success = success
16448 
 
16449 
  def read(self, iprot):
16450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16452 
      return
16453 
    iprot.readStructBegin()
16454 
    while True:
16455 
      (fname, ftype, fid) = iprot.readFieldBegin()
16456 
      if ftype == TType.STOP:
16457 
        break
16458 
      if fid == 0:
16459 
        if ftype == TType.LIST:
16460 
          self.success = []
5411 rajveer 16461 
          (_etype385, _size382) = iprot.readListBegin()
16462 
          for _i386 in xrange(_size382):
16463 
            _elem387 = ReturnOrder()
16464 
            _elem387.read(iprot)
16465 
            self.success.append(_elem387)
2690 chandransh 16466 
          iprot.readListEnd()
16467 
        else:
16468 
          iprot.skip(ftype)
16469 
      else:
16470 
        iprot.skip(ftype)
16471 
      iprot.readFieldEnd()
16472 
    iprot.readStructEnd()
16473 
 
16474 
  def write(self, oprot):
16475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16477 
      return
16478 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16479 
    if self.success is not None:
2690 chandransh 16480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16482 
      for iter388 in self.success:
16483 
        iter388.write(oprot)
2690 chandransh 16484 
      oprot.writeListEnd()
16485 
      oprot.writeFieldEnd()
16486 
    oprot.writeFieldStop()
16487 
    oprot.writeStructEnd()
16488 
 
3431 rajveer 16489 
  def validate(self):
16490 
    return
16491 
 
16492 
 
2690 chandransh 16493 
  def __repr__(self):
16494 
    L = ['%s=%r' % (key, value)
16495 
      for key, value in self.__dict__.iteritems()]
16496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16497 
 
16498 
  def __eq__(self, other):
16499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16500 
 
16501 
  def __ne__(self, other):
16502 
    return not (self == other)
16503 
 
2700 chandransh 16504 
class getReturnOrder_args:
16505 
  """
16506 
  Attributes:
16507 
   - id
16508 
  """
16509 
 
16510 
  thrift_spec = (
16511 
    None, # 0
16512 
    (1, TType.I64, 'id', None, None, ), # 1
16513 
  )
16514 
 
16515 
  def __init__(self, id=None,):
16516 
    self.id = id
16517 
 
16518 
  def read(self, iprot):
16519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16521 
      return
16522 
    iprot.readStructBegin()
16523 
    while True:
16524 
      (fname, ftype, fid) = iprot.readFieldBegin()
16525 
      if ftype == TType.STOP:
16526 
        break
16527 
      if fid == 1:
16528 
        if ftype == TType.I64:
16529 
          self.id = iprot.readI64();
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16542 
    if self.id is not None:
2700 chandransh 16543 
      oprot.writeFieldBegin('id', TType.I64, 1)
16544 
      oprot.writeI64(self.id)
16545 
      oprot.writeFieldEnd()
16546 
    oprot.writeFieldStop()
16547 
    oprot.writeStructEnd()
16548 
 
3431 rajveer 16549 
  def validate(self):
16550 
    return
16551 
 
16552 
 
2700 chandransh 16553 
  def __repr__(self):
16554 
    L = ['%s=%r' % (key, value)
16555 
      for key, value in self.__dict__.iteritems()]
16556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16557 
 
16558 
  def __eq__(self, other):
16559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16560 
 
16561 
  def __ne__(self, other):
16562 
    return not (self == other)
16563 
 
16564 
class getReturnOrder_result:
16565 
  """
16566 
  Attributes:
16567 
   - success
16568 
   - ex
16569 
  """
16570 
 
16571 
  thrift_spec = (
16572 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16574 
  )
16575 
 
16576 
  def __init__(self, success=None, ex=None,):
16577 
    self.success = success
16578 
    self.ex = ex
16579 
 
16580 
  def read(self, iprot):
16581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16583 
      return
16584 
    iprot.readStructBegin()
16585 
    while True:
16586 
      (fname, ftype, fid) = iprot.readFieldBegin()
16587 
      if ftype == TType.STOP:
16588 
        break
16589 
      if fid == 0:
16590 
        if ftype == TType.STRUCT:
16591 
          self.success = ReturnOrder()
16592 
          self.success.read(iprot)
16593 
        else:
16594 
          iprot.skip(ftype)
16595 
      elif fid == 1:
16596 
        if ftype == TType.STRUCT:
16597 
          self.ex = TransactionServiceException()
16598 
          self.ex.read(iprot)
16599 
        else:
16600 
          iprot.skip(ftype)
16601 
      else:
16602 
        iprot.skip(ftype)
16603 
      iprot.readFieldEnd()
16604 
    iprot.readStructEnd()
16605 
 
16606 
  def write(self, oprot):
16607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16609 
      return
16610 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16611 
    if self.success is not None:
2700 chandransh 16612 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16613 
      self.success.write(oprot)
16614 
      oprot.writeFieldEnd()
3431 rajveer 16615 
    if self.ex is not None:
2700 chandransh 16616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16617 
      self.ex.write(oprot)
16618 
      oprot.writeFieldEnd()
16619 
    oprot.writeFieldStop()
16620 
    oprot.writeStructEnd()
16621 
 
3431 rajveer 16622 
  def validate(self):
16623 
    return
16624 
 
16625 
 
2700 chandransh 16626 
  def __repr__(self):
16627 
    L = ['%s=%r' % (key, value)
16628 
      for key, value in self.__dict__.iteritems()]
16629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16630 
 
16631 
  def __eq__(self, other):
16632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16633 
 
16634 
  def __ne__(self, other):
16635 
    return not (self == other)
16636 
 
2690 chandransh 16637 
class processReturn_args:
16638 
  """
16639 
  Attributes:
16640 
   - returnOrderId
16641 
  """
16642 
 
16643 
  thrift_spec = (
16644 
    None, # 0
16645 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16646 
  )
16647 
 
16648 
  def __init__(self, returnOrderId=None,):
16649 
    self.returnOrderId = returnOrderId
16650 
 
16651 
  def read(self, iprot):
16652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16654 
      return
16655 
    iprot.readStructBegin()
16656 
    while True:
16657 
      (fname, ftype, fid) = iprot.readFieldBegin()
16658 
      if ftype == TType.STOP:
16659 
        break
16660 
      if fid == 1:
16661 
        if ftype == TType.I64:
16662 
          self.returnOrderId = iprot.readI64();
16663 
        else:
16664 
          iprot.skip(ftype)
16665 
      else:
16666 
        iprot.skip(ftype)
16667 
      iprot.readFieldEnd()
16668 
    iprot.readStructEnd()
16669 
 
16670 
  def write(self, oprot):
16671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16673 
      return
16674 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16675 
    if self.returnOrderId is not None:
2690 chandransh 16676 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16677 
      oprot.writeI64(self.returnOrderId)
16678 
      oprot.writeFieldEnd()
16679 
    oprot.writeFieldStop()
16680 
    oprot.writeStructEnd()
16681 
 
3431 rajveer 16682 
  def validate(self):
16683 
    return
16684 
 
16685 
 
2690 chandransh 16686 
  def __repr__(self):
16687 
    L = ['%s=%r' % (key, value)
16688 
      for key, value in self.__dict__.iteritems()]
16689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16690 
 
16691 
  def __eq__(self, other):
16692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16693 
 
16694 
  def __ne__(self, other):
16695 
    return not (self == other)
16696 
 
16697 
class processReturn_result:
16698 
  """
16699 
  Attributes:
16700 
   - ex
16701 
  """
16702 
 
16703 
  thrift_spec = (
16704 
    None, # 0
16705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16706 
  )
16707 
 
16708 
  def __init__(self, ex=None,):
16709 
    self.ex = ex
16710 
 
16711 
  def read(self, iprot):
16712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16714 
      return
16715 
    iprot.readStructBegin()
16716 
    while True:
16717 
      (fname, ftype, fid) = iprot.readFieldBegin()
16718 
      if ftype == TType.STOP:
16719 
        break
16720 
      if fid == 1:
16721 
        if ftype == TType.STRUCT:
16722 
          self.ex = TransactionServiceException()
16723 
          self.ex.read(iprot)
16724 
        else:
16725 
          iprot.skip(ftype)
16726 
      else:
16727 
        iprot.skip(ftype)
16728 
      iprot.readFieldEnd()
16729 
    iprot.readStructEnd()
16730 
 
16731 
  def write(self, oprot):
16732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16734 
      return
16735 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16736 
    if self.ex is not None:
2690 chandransh 16737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16738 
      self.ex.write(oprot)
16739 
      oprot.writeFieldEnd()
16740 
    oprot.writeFieldStop()
16741 
    oprot.writeStructEnd()
16742 
 
3431 rajveer 16743 
  def validate(self):
16744 
    return
16745 
 
16746 
 
2690 chandransh 16747 
  def __repr__(self):
16748 
    L = ['%s=%r' % (key, value)
16749 
      for key, value in self.__dict__.iteritems()]
16750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16751 
 
16752 
  def __eq__(self, other):
16753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16754 
 
16755 
  def __ne__(self, other):
16756 
    return not (self == other)
16757 
 
3451 chandransh 16758 
class updateWeight_args:
16759 
  """
16760 
  Attributes:
16761 
   - orderId
16762 
   - weight
16763 
  """
16764 
 
16765 
  thrift_spec = (
16766 
    None, # 0
16767 
    (1, TType.I64, 'orderId', None, None, ), # 1
16768 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16769 
  )
16770 
 
16771 
  def __init__(self, orderId=None, weight=None,):
16772 
    self.orderId = orderId
16773 
    self.weight = weight
16774 
 
16775 
  def read(self, iprot):
16776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16778 
      return
16779 
    iprot.readStructBegin()
16780 
    while True:
16781 
      (fname, ftype, fid) = iprot.readFieldBegin()
16782 
      if ftype == TType.STOP:
16783 
        break
16784 
      if fid == 1:
16785 
        if ftype == TType.I64:
16786 
          self.orderId = iprot.readI64();
16787 
        else:
16788 
          iprot.skip(ftype)
16789 
      elif fid == 2:
16790 
        if ftype == TType.DOUBLE:
16791 
          self.weight = iprot.readDouble();
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('updateWeight_args')
16804 
    if self.orderId is not None:
16805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16806 
      oprot.writeI64(self.orderId)
16807 
      oprot.writeFieldEnd()
16808 
    if self.weight is not None:
16809 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16810 
      oprot.writeDouble(self.weight)
16811 
      oprot.writeFieldEnd()
16812 
    oprot.writeFieldStop()
16813 
    oprot.writeStructEnd()
16814 
 
16815 
  def validate(self):
16816 
    return
16817 
 
16818 
 
16819 
  def __repr__(self):
16820 
    L = ['%s=%r' % (key, value)
16821 
      for key, value in self.__dict__.iteritems()]
16822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16823 
 
16824 
  def __eq__(self, other):
16825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16826 
 
16827 
  def __ne__(self, other):
16828 
    return not (self == other)
16829 
 
16830 
class updateWeight_result:
16831 
  """
16832 
  Attributes:
16833 
   - success
16834 
   - ex
16835 
  """
16836 
 
16837 
  thrift_spec = (
16838 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16840 
  )
16841 
 
16842 
  def __init__(self, success=None, ex=None,):
16843 
    self.success = success
16844 
    self.ex = ex
16845 
 
16846 
  def read(self, iprot):
16847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16849 
      return
16850 
    iprot.readStructBegin()
16851 
    while True:
16852 
      (fname, ftype, fid) = iprot.readFieldBegin()
16853 
      if ftype == TType.STOP:
16854 
        break
16855 
      if fid == 0:
16856 
        if ftype == TType.STRUCT:
16857 
          self.success = Order()
16858 
          self.success.read(iprot)
16859 
        else:
16860 
          iprot.skip(ftype)
16861 
      elif fid == 1:
16862 
        if ftype == TType.STRUCT:
16863 
          self.ex = TransactionServiceException()
16864 
          self.ex.read(iprot)
16865 
        else:
16866 
          iprot.skip(ftype)
16867 
      else:
16868 
        iprot.skip(ftype)
16869 
      iprot.readFieldEnd()
16870 
    iprot.readStructEnd()
16871 
 
16872 
  def write(self, oprot):
16873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16875 
      return
16876 
    oprot.writeStructBegin('updateWeight_result')
16877 
    if self.success is not None:
16878 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16879 
      self.success.write(oprot)
16880 
      oprot.writeFieldEnd()
16881 
    if self.ex is not None:
16882 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16883 
      self.ex.write(oprot)
16884 
      oprot.writeFieldEnd()
16885 
    oprot.writeFieldStop()
16886 
    oprot.writeStructEnd()
16887 
 
16888 
  def validate(self):
16889 
    return
16890 
 
16891 
 
16892 
  def __repr__(self):
16893 
    L = ['%s=%r' % (key, value)
16894 
      for key, value in self.__dict__.iteritems()]
16895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16896 
 
16897 
  def __eq__(self, other):
16898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16899 
 
16900 
  def __ne__(self, other):
16901 
    return not (self == other)
3469 chandransh 16902 
 
16903 
class changeItem_args:
16904 
  """
16905 
  Attributes:
16906 
   - orderId
16907 
   - itemId
16908 
  """
16909 
 
16910 
  thrift_spec = (
16911 
    None, # 0
16912 
    (1, TType.I64, 'orderId', None, None, ), # 1
16913 
    (2, TType.I64, 'itemId', None, None, ), # 2
16914 
  )
16915 
 
16916 
  def __init__(self, orderId=None, itemId=None,):
16917 
    self.orderId = orderId
16918 
    self.itemId = itemId
16919 
 
16920 
  def read(self, iprot):
16921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16923 
      return
16924 
    iprot.readStructBegin()
16925 
    while True:
16926 
      (fname, ftype, fid) = iprot.readFieldBegin()
16927 
      if ftype == TType.STOP:
16928 
        break
16929 
      if fid == 1:
16930 
        if ftype == TType.I64:
16931 
          self.orderId = iprot.readI64();
16932 
        else:
16933 
          iprot.skip(ftype)
16934 
      elif fid == 2:
16935 
        if ftype == TType.I64:
16936 
          self.itemId = iprot.readI64();
16937 
        else:
16938 
          iprot.skip(ftype)
16939 
      else:
16940 
        iprot.skip(ftype)
16941 
      iprot.readFieldEnd()
16942 
    iprot.readStructEnd()
16943 
 
16944 
  def write(self, oprot):
16945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16947 
      return
16948 
    oprot.writeStructBegin('changeItem_args')
16949 
    if self.orderId is not None:
16950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16951 
      oprot.writeI64(self.orderId)
16952 
      oprot.writeFieldEnd()
16953 
    if self.itemId is not None:
16954 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16955 
      oprot.writeI64(self.itemId)
16956 
      oprot.writeFieldEnd()
16957 
    oprot.writeFieldStop()
16958 
    oprot.writeStructEnd()
16959 
 
16960 
  def validate(self):
16961 
    return
16962 
 
16963 
 
16964 
  def __repr__(self):
16965 
    L = ['%s=%r' % (key, value)
16966 
      for key, value in self.__dict__.iteritems()]
16967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16968 
 
16969 
  def __eq__(self, other):
16970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16971 
 
16972 
  def __ne__(self, other):
16973 
    return not (self == other)
16974 
 
16975 
class changeItem_result:
16976 
  """
16977 
  Attributes:
16978 
   - success
16979 
   - ex
16980 
  """
16981 
 
16982 
  thrift_spec = (
16983 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16985 
  )
16986 
 
16987 
  def __init__(self, success=None, ex=None,):
16988 
    self.success = success
16989 
    self.ex = ex
16990 
 
16991 
  def read(self, iprot):
16992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16994 
      return
16995 
    iprot.readStructBegin()
16996 
    while True:
16997 
      (fname, ftype, fid) = iprot.readFieldBegin()
16998 
      if ftype == TType.STOP:
16999 
        break
17000 
      if fid == 0:
17001 
        if ftype == TType.STRUCT:
17002 
          self.success = Order()
17003 
          self.success.read(iprot)
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      elif fid == 1:
17007 
        if ftype == TType.STRUCT:
17008 
          self.ex = TransactionServiceException()
17009 
          self.ex.read(iprot)
17010 
        else:
17011 
          iprot.skip(ftype)
17012 
      else:
17013 
        iprot.skip(ftype)
17014 
      iprot.readFieldEnd()
17015 
    iprot.readStructEnd()
17016 
 
17017 
  def write(self, oprot):
17018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17020 
      return
17021 
    oprot.writeStructBegin('changeItem_result')
17022 
    if self.success is not None:
17023 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17024 
      self.success.write(oprot)
17025 
      oprot.writeFieldEnd()
17026 
    if self.ex is not None:
17027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17028 
      self.ex.write(oprot)
17029 
      oprot.writeFieldEnd()
17030 
    oprot.writeFieldStop()
17031 
    oprot.writeStructEnd()
17032 
 
17033 
  def validate(self):
17034 
    return
17035 
 
17036 
 
17037 
  def __repr__(self):
17038 
    L = ['%s=%r' % (key, value)
17039 
      for key, value in self.__dict__.iteritems()]
17040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17041 
 
17042 
  def __eq__(self, other):
17043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17044 
 
17045 
  def __ne__(self, other):
17046 
    return not (self == other)
17047 
 
17048 
class shiftToWarehouse_args:
17049 
  """
17050 
  Attributes:
17051 
   - orderId
17052 
   - warehouseId
17053 
  """
17054 
 
17055 
  thrift_spec = (
17056 
    None, # 0
17057 
    (1, TType.I64, 'orderId', None, None, ), # 1
17058 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17059 
  )
17060 
 
17061 
  def __init__(self, orderId=None, warehouseId=None,):
17062 
    self.orderId = orderId
17063 
    self.warehouseId = warehouseId
17064 
 
17065 
  def read(self, iprot):
17066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17068 
      return
17069 
    iprot.readStructBegin()
17070 
    while True:
17071 
      (fname, ftype, fid) = iprot.readFieldBegin()
17072 
      if ftype == TType.STOP:
17073 
        break
17074 
      if fid == 1:
17075 
        if ftype == TType.I64:
17076 
          self.orderId = iprot.readI64();
17077 
        else:
17078 
          iprot.skip(ftype)
17079 
      elif fid == 2:
17080 
        if ftype == TType.I64:
17081 
          self.warehouseId = iprot.readI64();
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      else:
17085 
        iprot.skip(ftype)
17086 
      iprot.readFieldEnd()
17087 
    iprot.readStructEnd()
17088 
 
17089 
  def write(self, oprot):
17090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17092 
      return
17093 
    oprot.writeStructBegin('shiftToWarehouse_args')
17094 
    if self.orderId is not None:
17095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17096 
      oprot.writeI64(self.orderId)
17097 
      oprot.writeFieldEnd()
17098 
    if self.warehouseId is not None:
17099 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17100 
      oprot.writeI64(self.warehouseId)
17101 
      oprot.writeFieldEnd()
17102 
    oprot.writeFieldStop()
17103 
    oprot.writeStructEnd()
17104 
 
17105 
  def validate(self):
17106 
    return
17107 
 
17108 
 
17109 
  def __repr__(self):
17110 
    L = ['%s=%r' % (key, value)
17111 
      for key, value in self.__dict__.iteritems()]
17112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17113 
 
17114 
  def __eq__(self, other):
17115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17116 
 
17117 
  def __ne__(self, other):
17118 
    return not (self == other)
17119 
 
17120 
class shiftToWarehouse_result:
17121 
  """
17122 
  Attributes:
17123 
   - success
17124 
   - ex
17125 
  """
17126 
 
17127 
  thrift_spec = (
17128 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17130 
  )
17131 
 
17132 
  def __init__(self, success=None, ex=None,):
17133 
    self.success = success
17134 
    self.ex = ex
17135 
 
17136 
  def read(self, iprot):
17137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17139 
      return
17140 
    iprot.readStructBegin()
17141 
    while True:
17142 
      (fname, ftype, fid) = iprot.readFieldBegin()
17143 
      if ftype == TType.STOP:
17144 
        break
17145 
      if fid == 0:
17146 
        if ftype == TType.STRUCT:
17147 
          self.success = Order()
17148 
          self.success.read(iprot)
17149 
        else:
17150 
          iprot.skip(ftype)
17151 
      elif fid == 1:
17152 
        if ftype == TType.STRUCT:
17153 
          self.ex = TransactionServiceException()
17154 
          self.ex.read(iprot)
17155 
        else:
17156 
          iprot.skip(ftype)
17157 
      else:
17158 
        iprot.skip(ftype)
17159 
      iprot.readFieldEnd()
17160 
    iprot.readStructEnd()
17161 
 
17162 
  def write(self, oprot):
17163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17165 
      return
17166 
    oprot.writeStructBegin('shiftToWarehouse_result')
17167 
    if self.success is not None:
17168 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17169 
      self.success.write(oprot)
17170 
      oprot.writeFieldEnd()
17171 
    if self.ex is not None:
17172 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17173 
      self.ex.write(oprot)
17174 
      oprot.writeFieldEnd()
17175 
    oprot.writeFieldStop()
17176 
    oprot.writeStructEnd()
17177 
 
17178 
  def validate(self):
17179 
    return
17180 
 
17181 
 
17182 
  def __repr__(self):
17183 
    L = ['%s=%r' % (key, value)
17184 
      for key, value in self.__dict__.iteritems()]
17185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17186 
 
17187 
  def __eq__(self, other):
17188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17189 
 
17190 
  def __ne__(self, other):
17191 
    return not (self == other)
3553 chandransh 17192 
 
17193 
class addDelayReason_args:
17194 
  """
17195 
  Attributes:
17196 
   - orderId
17197 
   - delayReason
3986 chandransh 17198 
   - furtherDelay
4647 rajveer 17199 
   - delayReasonText
3553 chandransh 17200 
  """
17201 
 
17202 
  thrift_spec = (
17203 
    None, # 0
17204 
    (1, TType.I64, 'orderId', None, None, ), # 1
17205 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17206 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17207 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17208 
  )
17209 
 
4647 rajveer 17210 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17211 
    self.orderId = orderId
17212 
    self.delayReason = delayReason
3986 chandransh 17213 
    self.furtherDelay = furtherDelay
4647 rajveer 17214 
    self.delayReasonText = delayReasonText
3553 chandransh 17215 
 
17216 
  def read(self, iprot):
17217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17219 
      return
17220 
    iprot.readStructBegin()
17221 
    while True:
17222 
      (fname, ftype, fid) = iprot.readFieldBegin()
17223 
      if ftype == TType.STOP:
17224 
        break
17225 
      if fid == 1:
17226 
        if ftype == TType.I64:
17227 
          self.orderId = iprot.readI64();
17228 
        else:
17229 
          iprot.skip(ftype)
17230 
      elif fid == 2:
17231 
        if ftype == TType.I32:
17232 
          self.delayReason = iprot.readI32();
17233 
        else:
17234 
          iprot.skip(ftype)
3986 chandransh 17235 
      elif fid == 3:
17236 
        if ftype == TType.I64:
17237 
          self.furtherDelay = iprot.readI64();
17238 
        else:
17239 
          iprot.skip(ftype)
4647 rajveer 17240 
      elif fid == 4:
17241 
        if ftype == TType.STRING:
17242 
          self.delayReasonText = iprot.readString();
17243 
        else:
17244 
          iprot.skip(ftype)
3553 chandransh 17245 
      else:
17246 
        iprot.skip(ftype)
17247 
      iprot.readFieldEnd()
17248 
    iprot.readStructEnd()
17249 
 
17250 
  def write(self, oprot):
17251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17253 
      return
17254 
    oprot.writeStructBegin('addDelayReason_args')
17255 
    if self.orderId is not None:
17256 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17257 
      oprot.writeI64(self.orderId)
17258 
      oprot.writeFieldEnd()
17259 
    if self.delayReason is not None:
17260 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17261 
      oprot.writeI32(self.delayReason)
17262 
      oprot.writeFieldEnd()
3986 chandransh 17263 
    if self.furtherDelay is not None:
17264 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17265 
      oprot.writeI64(self.furtherDelay)
17266 
      oprot.writeFieldEnd()
4647 rajveer 17267 
    if self.delayReasonText is not None:
17268 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17269 
      oprot.writeString(self.delayReasonText)
17270 
      oprot.writeFieldEnd()
3553 chandransh 17271 
    oprot.writeFieldStop()
17272 
    oprot.writeStructEnd()
17273 
 
17274 
  def validate(self):
17275 
    return
17276 
 
17277 
 
17278 
  def __repr__(self):
17279 
    L = ['%s=%r' % (key, value)
17280 
      for key, value in self.__dict__.iteritems()]
17281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17282 
 
17283 
  def __eq__(self, other):
17284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17285 
 
17286 
  def __ne__(self, other):
17287 
    return not (self == other)
17288 
 
17289 
class addDelayReason_result:
17290 
  """
17291 
  Attributes:
17292 
   - success
17293 
   - ex
17294 
  """
17295 
 
17296 
  thrift_spec = (
17297 
    (0, TType.BOOL, 'success', None, None, ), # 0
17298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17299 
  )
17300 
 
17301 
  def __init__(self, success=None, ex=None,):
17302 
    self.success = success
17303 
    self.ex = ex
17304 
 
17305 
  def read(self, iprot):
17306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17308 
      return
17309 
    iprot.readStructBegin()
17310 
    while True:
17311 
      (fname, ftype, fid) = iprot.readFieldBegin()
17312 
      if ftype == TType.STOP:
17313 
        break
17314 
      if fid == 0:
17315 
        if ftype == TType.BOOL:
17316 
          self.success = iprot.readBool();
17317 
        else:
17318 
          iprot.skip(ftype)
17319 
      elif fid == 1:
17320 
        if ftype == TType.STRUCT:
17321 
          self.ex = TransactionServiceException()
17322 
          self.ex.read(iprot)
17323 
        else:
17324 
          iprot.skip(ftype)
17325 
      else:
17326 
        iprot.skip(ftype)
17327 
      iprot.readFieldEnd()
17328 
    iprot.readStructEnd()
17329 
 
17330 
  def write(self, oprot):
17331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17333 
      return
17334 
    oprot.writeStructBegin('addDelayReason_result')
17335 
    if self.success is not None:
17336 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17337 
      oprot.writeBool(self.success)
17338 
      oprot.writeFieldEnd()
17339 
    if self.ex is not None:
17340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17341 
      self.ex.write(oprot)
17342 
      oprot.writeFieldEnd()
17343 
    oprot.writeFieldStop()
17344 
    oprot.writeStructEnd()
17345 
 
17346 
  def validate(self):
17347 
    return
17348 
 
17349 
 
17350 
  def __repr__(self):
17351 
    L = ['%s=%r' % (key, value)
17352 
      for key, value in self.__dict__.iteritems()]
17353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17354 
 
17355 
  def __eq__(self, other):
17356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17357 
 
17358 
  def __ne__(self, other):
17359 
    return not (self == other)
3956 chandransh 17360 
 
17361 
class reconcileCodCollection_args:
17362 
  """
17363 
  Attributes:
17364 
   - collectedAmountMap
17365 
   - xferBy
17366 
   - xferTxnId
17367 
   - xferDate
17368 
  """
17369 
 
17370 
  thrift_spec = (
17371 
    None, # 0
17372 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17373 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17374 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17375 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17376 
  )
17377 
 
17378 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17379 
    self.collectedAmountMap = collectedAmountMap
17380 
    self.xferBy = xferBy
17381 
    self.xferTxnId = xferTxnId
17382 
    self.xferDate = xferDate
17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      if fid == 1:
17394 
        if ftype == TType.MAP:
17395 
          self.collectedAmountMap = {}
5411 rajveer 17396 
          (_ktype390, _vtype391, _size389 ) = iprot.readMapBegin()
17397 
          for _i393 in xrange(_size389):
17398 
            _key394 = iprot.readString();
17399 
            _val395 = iprot.readDouble();
17400 
            self.collectedAmountMap[_key394] = _val395
3956 chandransh 17401 
          iprot.readMapEnd()
17402 
        else:
17403 
          iprot.skip(ftype)
17404 
      elif fid == 2:
17405 
        if ftype == TType.STRING:
17406 
          self.xferBy = iprot.readString();
17407 
        else:
17408 
          iprot.skip(ftype)
17409 
      elif fid == 3:
17410 
        if ftype == TType.STRING:
17411 
          self.xferTxnId = iprot.readString();
17412 
        else:
17413 
          iprot.skip(ftype)
17414 
      elif fid == 4:
17415 
        if ftype == TType.I64:
17416 
          self.xferDate = iprot.readI64();
17417 
        else:
17418 
          iprot.skip(ftype)
17419 
      else:
17420 
        iprot.skip(ftype)
17421 
      iprot.readFieldEnd()
17422 
    iprot.readStructEnd()
17423 
 
17424 
  def write(self, oprot):
17425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17427 
      return
17428 
    oprot.writeStructBegin('reconcileCodCollection_args')
17429 
    if self.collectedAmountMap is not None:
17430 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17431 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5411 rajveer 17432 
      for kiter396,viter397 in self.collectedAmountMap.items():
17433 
        oprot.writeString(kiter396)
17434 
        oprot.writeDouble(viter397)
3956 chandransh 17435 
      oprot.writeMapEnd()
17436 
      oprot.writeFieldEnd()
17437 
    if self.xferBy is not None:
17438 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17439 
      oprot.writeString(self.xferBy)
17440 
      oprot.writeFieldEnd()
17441 
    if self.xferTxnId is not None:
17442 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17443 
      oprot.writeString(self.xferTxnId)
17444 
      oprot.writeFieldEnd()
17445 
    if self.xferDate is not None:
17446 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17447 
      oprot.writeI64(self.xferDate)
17448 
      oprot.writeFieldEnd()
17449 
    oprot.writeFieldStop()
17450 
    oprot.writeStructEnd()
17451 
 
17452 
  def validate(self):
17453 
    return
17454 
 
17455 
 
17456 
  def __repr__(self):
17457 
    L = ['%s=%r' % (key, value)
17458 
      for key, value in self.__dict__.iteritems()]
17459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17460 
 
17461 
  def __eq__(self, other):
17462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17463 
 
17464 
  def __ne__(self, other):
17465 
    return not (self == other)
17466 
 
17467 
class reconcileCodCollection_result:
17468 
  """
17469 
  Attributes:
17470 
   - success
17471 
   - ex
17472 
  """
17473 
 
17474 
  thrift_spec = (
17475 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17477 
  )
17478 
 
17479 
  def __init__(self, success=None, ex=None,):
17480 
    self.success = success
17481 
    self.ex = ex
17482 
 
17483 
  def read(self, iprot):
17484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17486 
      return
17487 
    iprot.readStructBegin()
17488 
    while True:
17489 
      (fname, ftype, fid) = iprot.readFieldBegin()
17490 
      if ftype == TType.STOP:
17491 
        break
17492 
      if fid == 0:
17493 
        if ftype == TType.MAP:
17494 
          self.success = {}
5411 rajveer 17495 
          (_ktype399, _vtype400, _size398 ) = iprot.readMapBegin()
17496 
          for _i402 in xrange(_size398):
17497 
            _key403 = iprot.readString();
17498 
            _val404 = iprot.readString();
17499 
            self.success[_key403] = _val404
3956 chandransh 17500 
          iprot.readMapEnd()
17501 
        else:
17502 
          iprot.skip(ftype)
17503 
      elif fid == 1:
17504 
        if ftype == TType.STRUCT:
17505 
          self.ex = TransactionServiceException()
17506 
          self.ex.read(iprot)
17507 
        else:
17508 
          iprot.skip(ftype)
17509 
      else:
17510 
        iprot.skip(ftype)
17511 
      iprot.readFieldEnd()
17512 
    iprot.readStructEnd()
17513 
 
17514 
  def write(self, oprot):
17515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17517 
      return
17518 
    oprot.writeStructBegin('reconcileCodCollection_result')
17519 
    if self.success is not None:
17520 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17521 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5411 rajveer 17522 
      for kiter405,viter406 in self.success.items():
17523 
        oprot.writeString(kiter405)
17524 
        oprot.writeString(viter406)
3956 chandransh 17525 
      oprot.writeMapEnd()
17526 
      oprot.writeFieldEnd()
17527 
    if self.ex is not None:
17528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17529 
      self.ex.write(oprot)
17530 
      oprot.writeFieldEnd()
17531 
    oprot.writeFieldStop()
17532 
    oprot.writeStructEnd()
17533 
 
17534 
  def validate(self):
17535 
    return
17536 
 
17537 
 
17538 
  def __repr__(self):
17539 
    L = ['%s=%r' % (key, value)
17540 
      for key, value in self.__dict__.iteritems()]
17541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17542 
 
17543 
  def __eq__(self, other):
17544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17545 
 
17546 
  def __ne__(self, other):
17547 
    return not (self == other)
4008 mandeep.dh 17548 
 
17549 
class getTransactionsRequiringExtraProcessing_args:
17550 
  """
17551 
  Attributes:
17552 
   - category
17553 
  """
17554 
 
17555 
  thrift_spec = (
17556 
    None, # 0
17557 
    (1, TType.I32, 'category', None, None, ), # 1
17558 
  )
17559 
 
17560 
  def __init__(self, category=None,):
17561 
    self.category = category
17562 
 
17563 
  def read(self, iprot):
17564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17566 
      return
17567 
    iprot.readStructBegin()
17568 
    while True:
17569 
      (fname, ftype, fid) = iprot.readFieldBegin()
17570 
      if ftype == TType.STOP:
17571 
        break
17572 
      if fid == 1:
17573 
        if ftype == TType.I32:
17574 
          self.category = iprot.readI32();
17575 
        else:
17576 
          iprot.skip(ftype)
17577 
      else:
17578 
        iprot.skip(ftype)
17579 
      iprot.readFieldEnd()
17580 
    iprot.readStructEnd()
17581 
 
17582 
  def write(self, oprot):
17583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17585 
      return
17586 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17587 
    if self.category is not None:
17588 
      oprot.writeFieldBegin('category', TType.I32, 1)
17589 
      oprot.writeI32(self.category)
17590 
      oprot.writeFieldEnd()
17591 
    oprot.writeFieldStop()
17592 
    oprot.writeStructEnd()
17593 
 
17594 
  def validate(self):
17595 
    return
17596 
 
17597 
 
17598 
  def __repr__(self):
17599 
    L = ['%s=%r' % (key, value)
17600 
      for key, value in self.__dict__.iteritems()]
17601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17602 
 
17603 
  def __eq__(self, other):
17604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17605 
 
17606 
  def __ne__(self, other):
17607 
    return not (self == other)
17608 
 
17609 
class getTransactionsRequiringExtraProcessing_result:
17610 
  """
17611 
  Attributes:
17612 
   - success
17613 
  """
17614 
 
17615 
  thrift_spec = (
17616 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17617 
  )
17618 
 
17619 
  def __init__(self, success=None,):
17620 
    self.success = success
17621 
 
17622 
  def read(self, iprot):
17623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17625 
      return
17626 
    iprot.readStructBegin()
17627 
    while True:
17628 
      (fname, ftype, fid) = iprot.readFieldBegin()
17629 
      if ftype == TType.STOP:
17630 
        break
17631 
      if fid == 0:
17632 
        if ftype == TType.LIST:
17633 
          self.success = []
5411 rajveer 17634 
          (_etype410, _size407) = iprot.readListBegin()
17635 
          for _i411 in xrange(_size407):
17636 
            _elem412 = iprot.readI64();
17637 
            self.success.append(_elem412)
4008 mandeep.dh 17638 
          iprot.readListEnd()
17639 
        else:
17640 
          iprot.skip(ftype)
17641 
      else:
17642 
        iprot.skip(ftype)
17643 
      iprot.readFieldEnd()
17644 
    iprot.readStructEnd()
17645 
 
17646 
  def write(self, oprot):
17647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17649 
      return
17650 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17651 
    if self.success is not None:
17652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17653 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 17654 
      for iter413 in self.success:
17655 
        oprot.writeI64(iter413)
4008 mandeep.dh 17656 
      oprot.writeListEnd()
17657 
      oprot.writeFieldEnd()
17658 
    oprot.writeFieldStop()
17659 
    oprot.writeStructEnd()
17660 
 
17661 
  def validate(self):
17662 
    return
17663 
 
17664 
 
17665 
  def __repr__(self):
17666 
    L = ['%s=%r' % (key, value)
17667 
      for key, value in self.__dict__.iteritems()]
17668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17669 
 
17670 
  def __eq__(self, other):
17671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17672 
 
17673 
  def __ne__(self, other):
17674 
    return not (self == other)
17675 
 
17676 
class markTransactionAsProcessed_args:
17677 
  """
17678 
  Attributes:
17679 
   - transactionId
17680 
   - category
17681 
  """
17682 
 
17683 
  thrift_spec = (
17684 
    None, # 0
17685 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17686 
    (2, TType.I32, 'category', None, None, ), # 2
17687 
  )
17688 
 
17689 
  def __init__(self, transactionId=None, category=None,):
17690 
    self.transactionId = transactionId
17691 
    self.category = category
17692 
 
17693 
  def read(self, iprot):
17694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17696 
      return
17697 
    iprot.readStructBegin()
17698 
    while True:
17699 
      (fname, ftype, fid) = iprot.readFieldBegin()
17700 
      if ftype == TType.STOP:
17701 
        break
17702 
      if fid == 1:
17703 
        if ftype == TType.I64:
17704 
          self.transactionId = iprot.readI64();
17705 
        else:
17706 
          iprot.skip(ftype)
17707 
      elif fid == 2:
17708 
        if ftype == TType.I32:
17709 
          self.category = iprot.readI32();
17710 
        else:
17711 
          iprot.skip(ftype)
17712 
      else:
17713 
        iprot.skip(ftype)
17714 
      iprot.readFieldEnd()
17715 
    iprot.readStructEnd()
17716 
 
17717 
  def write(self, oprot):
17718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17720 
      return
17721 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17722 
    if self.transactionId is not None:
17723 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17724 
      oprot.writeI64(self.transactionId)
17725 
      oprot.writeFieldEnd()
17726 
    if self.category is not None:
17727 
      oprot.writeFieldBegin('category', TType.I32, 2)
17728 
      oprot.writeI32(self.category)
17729 
      oprot.writeFieldEnd()
17730 
    oprot.writeFieldStop()
17731 
    oprot.writeStructEnd()
17732 
 
17733 
  def validate(self):
17734 
    return
17735 
 
17736 
 
17737 
  def __repr__(self):
17738 
    L = ['%s=%r' % (key, value)
17739 
      for key, value in self.__dict__.iteritems()]
17740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17741 
 
17742 
  def __eq__(self, other):
17743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17744 
 
17745 
  def __ne__(self, other):
17746 
    return not (self == other)
17747 
 
17748 
class markTransactionAsProcessed_result:
17749 
 
17750 
  thrift_spec = (
17751 
  )
17752 
 
17753 
  def read(self, iprot):
17754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17756 
      return
17757 
    iprot.readStructBegin()
17758 
    while True:
17759 
      (fname, ftype, fid) = iprot.readFieldBegin()
17760 
      if ftype == TType.STOP:
17761 
        break
17762 
      else:
17763 
        iprot.skip(ftype)
17764 
      iprot.readFieldEnd()
17765 
    iprot.readStructEnd()
17766 
 
17767 
  def write(self, oprot):
17768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17770 
      return
17771 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17772 
    oprot.writeFieldStop()
17773 
    oprot.writeStructEnd()
17774 
 
17775 
  def validate(self):
17776 
    return
17777 
 
17778 
 
17779 
  def __repr__(self):
17780 
    L = ['%s=%r' % (key, value)
17781 
      for key, value in self.__dict__.iteritems()]
17782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17783 
 
17784 
  def __eq__(self, other):
17785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17786 
 
17787 
  def __ne__(self, other):
17788 
    return not (self == other)
4018 chandransh 17789 
 
17790 
class getItemWiseRiskyOrdersCount_args:
17791 
 
17792 
  thrift_spec = (
17793 
  )
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      else:
17805 
        iprot.skip(ftype)
17806 
      iprot.readFieldEnd()
17807 
    iprot.readStructEnd()
17808 
 
17809 
  def write(self, oprot):
17810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17812 
      return
17813 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17814 
    oprot.writeFieldStop()
17815 
    oprot.writeStructEnd()
17816 
 
17817 
  def validate(self):
17818 
    return
17819 
 
17820 
 
17821 
  def __repr__(self):
17822 
    L = ['%s=%r' % (key, value)
17823 
      for key, value in self.__dict__.iteritems()]
17824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17825 
 
17826 
  def __eq__(self, other):
17827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17828 
 
17829 
  def __ne__(self, other):
17830 
    return not (self == other)
17831 
 
17832 
class getItemWiseRiskyOrdersCount_result:
17833 
  """
17834 
  Attributes:
17835 
   - success
17836 
  """
17837 
 
17838 
  thrift_spec = (
17839 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17840 
  )
17841 
 
17842 
  def __init__(self, success=None,):
17843 
    self.success = success
17844 
 
17845 
  def read(self, iprot):
17846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17848 
      return
17849 
    iprot.readStructBegin()
17850 
    while True:
17851 
      (fname, ftype, fid) = iprot.readFieldBegin()
17852 
      if ftype == TType.STOP:
17853 
        break
17854 
      if fid == 0:
17855 
        if ftype == TType.MAP:
17856 
          self.success = {}
5411 rajveer 17857 
          (_ktype415, _vtype416, _size414 ) = iprot.readMapBegin()
17858 
          for _i418 in xrange(_size414):
17859 
            _key419 = iprot.readI64();
17860 
            _val420 = iprot.readI64();
17861 
            self.success[_key419] = _val420
4018 chandransh 17862 
          iprot.readMapEnd()
17863 
        else:
17864 
          iprot.skip(ftype)
17865 
      else:
17866 
        iprot.skip(ftype)
17867 
      iprot.readFieldEnd()
17868 
    iprot.readStructEnd()
17869 
 
17870 
  def write(self, oprot):
17871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17873 
      return
17874 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17875 
    if self.success is not None:
17876 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17877 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5411 rajveer 17878 
      for kiter421,viter422 in self.success.items():
17879 
        oprot.writeI64(kiter421)
17880 
        oprot.writeI64(viter422)
4018 chandransh 17881 
      oprot.writeMapEnd()
17882 
      oprot.writeFieldEnd()
17883 
    oprot.writeFieldStop()
17884 
    oprot.writeStructEnd()
17885 
 
17886 
  def validate(self):
17887 
    return
17888 
 
17889 
 
17890 
  def __repr__(self):
17891 
    L = ['%s=%r' % (key, value)
17892 
      for key, value in self.__dict__.iteritems()]
17893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17894 
 
17895 
  def __eq__(self, other):
17896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17897 
 
17898 
  def __ne__(self, other):
17899 
    return not (self == other)
4247 rajveer 17900 
 
4295 varun.gupt 17901 
class getOrdersForItemIds_args:
17902 
  """
17903 
  Attributes:
17904 
   - itemIds
17905 
  """
17906 
 
17907 
  thrift_spec = (
17908 
    None, # 0
17909 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17910 
  )
17911 
 
17912 
  def __init__(self, itemIds=None,):
17913 
    self.itemIds = itemIds
17914 
 
17915 
  def read(self, iprot):
17916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17918 
      return
17919 
    iprot.readStructBegin()
17920 
    while True:
17921 
      (fname, ftype, fid) = iprot.readFieldBegin()
17922 
      if ftype == TType.STOP:
17923 
        break
17924 
      if fid == 1:
17925 
        if ftype == TType.LIST:
17926 
          self.itemIds = []
5411 rajveer 17927 
          (_etype426, _size423) = iprot.readListBegin()
17928 
          for _i427 in xrange(_size423):
17929 
            _elem428 = iprot.readI64();
17930 
            self.itemIds.append(_elem428)
4295 varun.gupt 17931 
          iprot.readListEnd()
17932 
        else:
17933 
          iprot.skip(ftype)
17934 
      else:
17935 
        iprot.skip(ftype)
17936 
      iprot.readFieldEnd()
17937 
    iprot.readStructEnd()
17938 
 
17939 
  def write(self, oprot):
17940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17942 
      return
17943 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17944 
    if self.itemIds is not None:
17945 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17946 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5411 rajveer 17947 
      for iter429 in self.itemIds:
17948 
        oprot.writeI64(iter429)
4295 varun.gupt 17949 
      oprot.writeListEnd()
17950 
      oprot.writeFieldEnd()
17951 
    oprot.writeFieldStop()
17952 
    oprot.writeStructEnd()
17953 
 
17954 
  def validate(self):
17955 
    return
17956 
 
17957 
 
17958 
  def __repr__(self):
17959 
    L = ['%s=%r' % (key, value)
17960 
      for key, value in self.__dict__.iteritems()]
17961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17962 
 
17963 
  def __eq__(self, other):
17964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17965 
 
17966 
  def __ne__(self, other):
17967 
    return not (self == other)
17968 
 
17969 
class getOrdersForItemIds_result:
17970 
  """
17971 
  Attributes:
17972 
   - success
17973 
  """
17974 
 
17975 
  thrift_spec = (
17976 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17977 
  )
17978 
 
17979 
  def __init__(self, success=None,):
17980 
    self.success = success
17981 
 
17982 
  def read(self, iprot):
17983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17985 
      return
17986 
    iprot.readStructBegin()
17987 
    while True:
17988 
      (fname, ftype, fid) = iprot.readFieldBegin()
17989 
      if ftype == TType.STOP:
17990 
        break
17991 
      if fid == 0:
17992 
        if ftype == TType.LIST:
17993 
          self.success = []
5411 rajveer 17994 
          (_etype433, _size430) = iprot.readListBegin()
17995 
          for _i434 in xrange(_size430):
17996 
            _elem435 = Order()
17997 
            _elem435.read(iprot)
17998 
            self.success.append(_elem435)
4295 varun.gupt 17999 
          iprot.readListEnd()
18000 
        else:
18001 
          iprot.skip(ftype)
18002 
      else:
18003 
        iprot.skip(ftype)
18004 
      iprot.readFieldEnd()
18005 
    iprot.readStructEnd()
18006 
 
18007 
  def write(self, oprot):
18008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18010 
      return
18011 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18012 
    if self.success is not None:
18013 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18014 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 18015 
      for iter436 in self.success:
18016 
        iter436.write(oprot)
4295 varun.gupt 18017 
      oprot.writeListEnd()
18018 
      oprot.writeFieldEnd()
18019 
    oprot.writeFieldStop()
18020 
    oprot.writeStructEnd()
18021 
 
18022 
  def validate(self):
18023 
    return
18024 
 
18025 
 
18026 
  def __repr__(self):
18027 
    L = ['%s=%r' % (key, value)
18028 
      for key, value in self.__dict__.iteritems()]
18029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18030 
 
18031 
  def __eq__(self, other):
18032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18033 
 
18034 
  def __ne__(self, other):
18035 
    return not (self == other)
18036 
 
4247 rajveer 18037 
class markOrderCancellationRequestReceived_args:
18038 
  """
18039 
  Attributes:
18040 
   - orderId
18041 
  """
18042 
 
18043 
  thrift_spec = (
18044 
    None, # 0
18045 
    (1, TType.I64, 'orderId', None, None, ), # 1
18046 
  )
18047 
 
18048 
  def __init__(self, orderId=None,):
18049 
    self.orderId = orderId
18050 
 
18051 
  def read(self, iprot):
18052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18054 
      return
18055 
    iprot.readStructBegin()
18056 
    while True:
18057 
      (fname, ftype, fid) = iprot.readFieldBegin()
18058 
      if ftype == TType.STOP:
18059 
        break
18060 
      if fid == 1:
18061 
        if ftype == TType.I64:
18062 
          self.orderId = iprot.readI64();
18063 
        else:
18064 
          iprot.skip(ftype)
18065 
      else:
18066 
        iprot.skip(ftype)
18067 
      iprot.readFieldEnd()
18068 
    iprot.readStructEnd()
18069 
 
18070 
  def write(self, oprot):
18071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18073 
      return
18074 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18075 
    if self.orderId is not None:
18076 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18077 
      oprot.writeI64(self.orderId)
18078 
      oprot.writeFieldEnd()
18079 
    oprot.writeFieldStop()
18080 
    oprot.writeStructEnd()
18081 
 
18082 
  def validate(self):
18083 
    return
18084 
 
18085 
 
18086 
  def __repr__(self):
18087 
    L = ['%s=%r' % (key, value)
18088 
      for key, value in self.__dict__.iteritems()]
18089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18090 
 
18091 
  def __eq__(self, other):
18092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18093 
 
18094 
  def __ne__(self, other):
18095 
    return not (self == other)
18096 
 
18097 
class markOrderCancellationRequestReceived_result:
18098 
  """
18099 
  Attributes:
18100 
   - ex
18101 
  """
18102 
 
18103 
  thrift_spec = (
18104 
    None, # 0
18105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18106 
  )
18107 
 
18108 
  def __init__(self, ex=None,):
18109 
    self.ex = ex
18110 
 
18111 
  def read(self, iprot):
18112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18114 
      return
18115 
    iprot.readStructBegin()
18116 
    while True:
18117 
      (fname, ftype, fid) = iprot.readFieldBegin()
18118 
      if ftype == TType.STOP:
18119 
        break
18120 
      if fid == 1:
18121 
        if ftype == TType.STRUCT:
18122 
          self.ex = TransactionServiceException()
18123 
          self.ex.read(iprot)
18124 
        else:
18125 
          iprot.skip(ftype)
18126 
      else:
18127 
        iprot.skip(ftype)
18128 
      iprot.readFieldEnd()
18129 
    iprot.readStructEnd()
18130 
 
18131 
  def write(self, oprot):
18132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18134 
      return
18135 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18136 
    if self.ex is not None:
18137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18138 
      self.ex.write(oprot)
18139 
      oprot.writeFieldEnd()
18140 
    oprot.writeFieldStop()
18141 
    oprot.writeStructEnd()
18142 
 
18143 
  def validate(self):
18144 
    return
18145 
 
18146 
 
18147 
  def __repr__(self):
18148 
    L = ['%s=%r' % (key, value)
18149 
      for key, value in self.__dict__.iteritems()]
18150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18151 
 
18152 
  def __eq__(self, other):
18153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18154 
 
18155 
  def __ne__(self, other):
18156 
    return not (self == other)
18157 
 
18158 
class markOrderCancellationRequestConfirmed_args:
18159 
  """
18160 
  Attributes:
18161 
   - orderId
18162 
  """
18163 
 
18164 
  thrift_spec = (
18165 
    None, # 0
18166 
    (1, TType.I64, 'orderId', None, None, ), # 1
18167 
  )
18168 
 
18169 
  def __init__(self, orderId=None,):
18170 
    self.orderId = orderId
18171 
 
18172 
  def read(self, iprot):
18173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18175 
      return
18176 
    iprot.readStructBegin()
18177 
    while True:
18178 
      (fname, ftype, fid) = iprot.readFieldBegin()
18179 
      if ftype == TType.STOP:
18180 
        break
18181 
      if fid == 1:
18182 
        if ftype == TType.I64:
18183 
          self.orderId = iprot.readI64();
18184 
        else:
18185 
          iprot.skip(ftype)
18186 
      else:
18187 
        iprot.skip(ftype)
18188 
      iprot.readFieldEnd()
18189 
    iprot.readStructEnd()
18190 
 
18191 
  def write(self, oprot):
18192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18194 
      return
18195 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18196 
    if self.orderId is not None:
18197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18198 
      oprot.writeI64(self.orderId)
18199 
      oprot.writeFieldEnd()
18200 
    oprot.writeFieldStop()
18201 
    oprot.writeStructEnd()
18202 
 
18203 
  def validate(self):
18204 
    return
18205 
 
18206 
 
18207 
  def __repr__(self):
18208 
    L = ['%s=%r' % (key, value)
18209 
      for key, value in self.__dict__.iteritems()]
18210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18211 
 
18212 
  def __eq__(self, other):
18213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18214 
 
18215 
  def __ne__(self, other):
18216 
    return not (self == other)
18217 
 
18218 
class markOrderCancellationRequestConfirmed_result:
18219 
  """
18220 
  Attributes:
18221 
   - ex
18222 
  """
18223 
 
18224 
  thrift_spec = (
18225 
    None, # 0
18226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18227 
  )
18228 
 
18229 
  def __init__(self, ex=None,):
18230 
    self.ex = ex
18231 
 
18232 
  def read(self, iprot):
18233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18235 
      return
18236 
    iprot.readStructBegin()
18237 
    while True:
18238 
      (fname, ftype, fid) = iprot.readFieldBegin()
18239 
      if ftype == TType.STOP:
18240 
        break
18241 
      if fid == 1:
18242 
        if ftype == TType.STRUCT:
18243 
          self.ex = TransactionServiceException()
18244 
          self.ex.read(iprot)
18245 
        else:
18246 
          iprot.skip(ftype)
18247 
      else:
18248 
        iprot.skip(ftype)
18249 
      iprot.readFieldEnd()
18250 
    iprot.readStructEnd()
18251 
 
18252 
  def write(self, oprot):
18253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18255 
      return
18256 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18257 
    if self.ex is not None:
18258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18259 
      self.ex.write(oprot)
18260 
      oprot.writeFieldEnd()
18261 
    oprot.writeFieldStop()
18262 
    oprot.writeStructEnd()
18263 
 
18264 
  def validate(self):
18265 
    return
18266 
 
18267 
 
18268 
  def __repr__(self):
18269 
    L = ['%s=%r' % (key, value)
18270 
      for key, value in self.__dict__.iteritems()]
18271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18272 
 
18273 
  def __eq__(self, other):
18274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18275 
 
18276 
  def __ne__(self, other):
18277 
    return not (self == other)
18278 
 
18279 
class markOrderCancellationRequestDenied_args:
18280 
  """
18281 
  Attributes:
18282 
   - orderId
18283 
  """
18284 
 
18285 
  thrift_spec = (
18286 
    None, # 0
18287 
    (1, TType.I64, 'orderId', None, None, ), # 1
18288 
  )
18289 
 
18290 
  def __init__(self, orderId=None,):
18291 
    self.orderId = orderId
18292 
 
18293 
  def read(self, iprot):
18294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18296 
      return
18297 
    iprot.readStructBegin()
18298 
    while True:
18299 
      (fname, ftype, fid) = iprot.readFieldBegin()
18300 
      if ftype == TType.STOP:
18301 
        break
18302 
      if fid == 1:
18303 
        if ftype == TType.I64:
18304 
          self.orderId = iprot.readI64();
18305 
        else:
18306 
          iprot.skip(ftype)
18307 
      else:
18308 
        iprot.skip(ftype)
18309 
      iprot.readFieldEnd()
18310 
    iprot.readStructEnd()
18311 
 
18312 
  def write(self, oprot):
18313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18315 
      return
18316 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18317 
    if self.orderId is not None:
18318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18319 
      oprot.writeI64(self.orderId)
18320 
      oprot.writeFieldEnd()
18321 
    oprot.writeFieldStop()
18322 
    oprot.writeStructEnd()
18323 
 
18324 
  def validate(self):
18325 
    return
18326 
 
18327 
 
18328 
  def __repr__(self):
18329 
    L = ['%s=%r' % (key, value)
18330 
      for key, value in self.__dict__.iteritems()]
18331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18332 
 
18333 
  def __eq__(self, other):
18334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18335 
 
18336 
  def __ne__(self, other):
18337 
    return not (self == other)
18338 
 
18339 
class markOrderCancellationRequestDenied_result:
18340 
  """
18341 
  Attributes:
18342 
   - ex
18343 
  """
18344 
 
18345 
  thrift_spec = (
18346 
    None, # 0
18347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18348 
  )
18349 
 
18350 
  def __init__(self, ex=None,):
18351 
    self.ex = ex
18352 
 
18353 
  def read(self, iprot):
18354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18356 
      return
18357 
    iprot.readStructBegin()
18358 
    while True:
18359 
      (fname, ftype, fid) = iprot.readFieldBegin()
18360 
      if ftype == TType.STOP:
18361 
        break
18362 
      if fid == 1:
18363 
        if ftype == TType.STRUCT:
18364 
          self.ex = TransactionServiceException()
18365 
          self.ex.read(iprot)
18366 
        else:
18367 
          iprot.skip(ftype)
18368 
      else:
18369 
        iprot.skip(ftype)
18370 
      iprot.readFieldEnd()
18371 
    iprot.readStructEnd()
18372 
 
18373 
  def write(self, oprot):
18374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18376 
      return
18377 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18378 
    if self.ex is not None:
18379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18380 
      self.ex.write(oprot)
18381 
      oprot.writeFieldEnd()
18382 
    oprot.writeFieldStop()
18383 
    oprot.writeStructEnd()
18384 
 
18385 
  def validate(self):
18386 
    return
18387 
 
18388 
 
18389 
  def __repr__(self):
18390 
    L = ['%s=%r' % (key, value)
18391 
      for key, value in self.__dict__.iteritems()]
18392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18393 
 
18394 
  def __eq__(self, other):
18395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18396 
 
18397 
  def __ne__(self, other):
18398 
    return not (self == other)
18399 
 
4258 rajveer 18400 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18401 
  """
18402 
  Attributes:
4258 rajveer 18403 
   - transactionId
4247 rajveer 18404 
  """
18405 
 
18406 
  thrift_spec = (
18407 
    None, # 0
4258 rajveer 18408 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18409 
  )
18410 
 
4258 rajveer 18411 
  def __init__(self, transactionId=None,):
18412 
    self.transactionId = transactionId
4247 rajveer 18413 
 
18414 
  def read(self, iprot):
18415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18417 
      return
18418 
    iprot.readStructBegin()
18419 
    while True:
18420 
      (fname, ftype, fid) = iprot.readFieldBegin()
18421 
      if ftype == TType.STOP:
18422 
        break
18423 
      if fid == 1:
18424 
        if ftype == TType.I64:
4258 rajveer 18425 
          self.transactionId = iprot.readI64();
4247 rajveer 18426 
        else:
18427 
          iprot.skip(ftype)
18428 
      else:
18429 
        iprot.skip(ftype)
18430 
      iprot.readFieldEnd()
18431 
    iprot.readStructEnd()
18432 
 
18433 
  def write(self, oprot):
18434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18436 
      return
4258 rajveer 18437 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18438 
    if self.transactionId is not None:
18439 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18440 
      oprot.writeI64(self.transactionId)
4247 rajveer 18441 
      oprot.writeFieldEnd()
18442 
    oprot.writeFieldStop()
18443 
    oprot.writeStructEnd()
18444 
 
18445 
  def validate(self):
18446 
    return
18447 
 
18448 
 
18449 
  def __repr__(self):
18450 
    L = ['%s=%r' % (key, value)
18451 
      for key, value in self.__dict__.iteritems()]
18452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18453 
 
18454 
  def __eq__(self, other):
18455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18456 
 
18457 
  def __ne__(self, other):
18458 
    return not (self == other)
18459 
 
4258 rajveer 18460 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18461 
  """
18462 
  Attributes:
18463 
   - ex
18464 
  """
18465 
 
18466 
  thrift_spec = (
18467 
    None, # 0
18468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18469 
  )
18470 
 
18471 
  def __init__(self, ex=None,):
18472 
    self.ex = ex
18473 
 
18474 
  def read(self, iprot):
18475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18477 
      return
18478 
    iprot.readStructBegin()
18479 
    while True:
18480 
      (fname, ftype, fid) = iprot.readFieldBegin()
18481 
      if ftype == TType.STOP:
18482 
        break
18483 
      if fid == 1:
18484 
        if ftype == TType.STRUCT:
18485 
          self.ex = TransactionServiceException()
18486 
          self.ex.read(iprot)
18487 
        else:
18488 
          iprot.skip(ftype)
18489 
      else:
18490 
        iprot.skip(ftype)
18491 
      iprot.readFieldEnd()
18492 
    iprot.readStructEnd()
18493 
 
18494 
  def write(self, oprot):
18495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18497 
      return
4258 rajveer 18498 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18499 
    if self.ex is not None:
18500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18501 
      self.ex.write(oprot)
18502 
      oprot.writeFieldEnd()
18503 
    oprot.writeFieldStop()
18504 
    oprot.writeStructEnd()
18505 
 
18506 
  def validate(self):
18507 
    return
18508 
 
18509 
 
18510 
  def __repr__(self):
18511 
    L = ['%s=%r' % (key, value)
18512 
      for key, value in self.__dict__.iteritems()]
18513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18514 
 
18515 
  def __eq__(self, other):
18516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18517 
 
18518 
  def __ne__(self, other):
18519 
    return not (self == other)
4259 anupam.sin 18520 
 
18521 
class refundTransaction_args:
18522 
  """
18523 
  Attributes:
18524 
   - transactionId
18525 
   - refundedBy
18526 
   - reason
18527 
  """
18528 
 
18529 
  thrift_spec = (
18530 
    None, # 0
18531 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18532 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18533 
    (3, TType.STRING, 'reason', None, None, ), # 3
18534 
  )
18535 
 
18536 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18537 
    self.transactionId = transactionId
18538 
    self.refundedBy = refundedBy
18539 
    self.reason = reason
18540 
 
18541 
  def read(self, iprot):
18542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18544 
      return
18545 
    iprot.readStructBegin()
18546 
    while True:
18547 
      (fname, ftype, fid) = iprot.readFieldBegin()
18548 
      if ftype == TType.STOP:
18549 
        break
18550 
      if fid == 1:
18551 
        if ftype == TType.I64:
18552 
          self.transactionId = iprot.readI64();
18553 
        else:
18554 
          iprot.skip(ftype)
18555 
      elif fid == 2:
18556 
        if ftype == TType.STRING:
18557 
          self.refundedBy = iprot.readString();
18558 
        else:
18559 
          iprot.skip(ftype)
18560 
      elif fid == 3:
18561 
        if ftype == TType.STRING:
18562 
          self.reason = iprot.readString();
18563 
        else:
18564 
          iprot.skip(ftype)
18565 
      else:
18566 
        iprot.skip(ftype)
18567 
      iprot.readFieldEnd()
18568 
    iprot.readStructEnd()
18569 
 
18570 
  def write(self, oprot):
18571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18573 
      return
18574 
    oprot.writeStructBegin('refundTransaction_args')
18575 
    if self.transactionId is not None:
18576 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18577 
      oprot.writeI64(self.transactionId)
18578 
      oprot.writeFieldEnd()
18579 
    if self.refundedBy is not None:
18580 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18581 
      oprot.writeString(self.refundedBy)
18582 
      oprot.writeFieldEnd()
18583 
    if self.reason is not None:
18584 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18585 
      oprot.writeString(self.reason)
18586 
      oprot.writeFieldEnd()
18587 
    oprot.writeFieldStop()
18588 
    oprot.writeStructEnd()
18589 
 
18590 
  def validate(self):
18591 
    return
18592 
 
18593 
 
18594 
  def __repr__(self):
18595 
    L = ['%s=%r' % (key, value)
18596 
      for key, value in self.__dict__.iteritems()]
18597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18598 
 
18599 
  def __eq__(self, other):
18600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18601 
 
18602 
  def __ne__(self, other):
18603 
    return not (self == other)
18604 
 
18605 
class refundTransaction_result:
18606 
  """
18607 
  Attributes:
18608 
   - ex
18609 
  """
18610 
 
18611 
  thrift_spec = (
18612 
    None, # 0
18613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18614 
  )
18615 
 
18616 
  def __init__(self, ex=None,):
18617 
    self.ex = ex
18618 
 
18619 
  def read(self, iprot):
18620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18622 
      return
18623 
    iprot.readStructBegin()
18624 
    while True:
18625 
      (fname, ftype, fid) = iprot.readFieldBegin()
18626 
      if ftype == TType.STOP:
18627 
        break
18628 
      if fid == 1:
18629 
        if ftype == TType.STRUCT:
18630 
          self.ex = TransactionServiceException()
18631 
          self.ex.read(iprot)
18632 
        else:
18633 
          iprot.skip(ftype)
18634 
      else:
18635 
        iprot.skip(ftype)
18636 
      iprot.readFieldEnd()
18637 
    iprot.readStructEnd()
18638 
 
18639 
  def write(self, oprot):
18640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18642 
      return
18643 
    oprot.writeStructBegin('refundTransaction_result')
18644 
    if self.ex is not None:
18645 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18646 
      self.ex.write(oprot)
18647 
      oprot.writeFieldEnd()
18648 
    oprot.writeFieldStop()
18649 
    oprot.writeStructEnd()
18650 
 
18651 
  def validate(self):
18652 
    return
18653 
 
18654 
 
18655 
  def __repr__(self):
18656 
    L = ['%s=%r' % (key, value)
18657 
      for key, value in self.__dict__.iteritems()]
18658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18659 
 
18660 
  def __eq__(self, other):
18661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18662 
 
18663 
  def __ne__(self, other):
18664 
    return not (self == other)
4285 rajveer 18665 
 
4324 mandeep.dh 18666 
class updateShipmentAddress_args:
18667 
  """
18668 
  Attributes:
18669 
   - orderId
18670 
   - addressId
18671 
  """
18672 
 
18673 
  thrift_spec = (
18674 
    None, # 0
18675 
    (1, TType.I64, 'orderId', None, None, ), # 1
18676 
    (2, TType.I64, 'addressId', None, None, ), # 2
18677 
  )
18678 
 
18679 
  def __init__(self, orderId=None, addressId=None,):
18680 
    self.orderId = orderId
18681 
    self.addressId = addressId
18682 
 
18683 
  def read(self, iprot):
18684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18686 
      return
18687 
    iprot.readStructBegin()
18688 
    while True:
18689 
      (fname, ftype, fid) = iprot.readFieldBegin()
18690 
      if ftype == TType.STOP:
18691 
        break
18692 
      if fid == 1:
18693 
        if ftype == TType.I64:
18694 
          self.orderId = iprot.readI64();
18695 
        else:
18696 
          iprot.skip(ftype)
18697 
      elif fid == 2:
18698 
        if ftype == TType.I64:
18699 
          self.addressId = iprot.readI64();
18700 
        else:
18701 
          iprot.skip(ftype)
18702 
      else:
18703 
        iprot.skip(ftype)
18704 
      iprot.readFieldEnd()
18705 
    iprot.readStructEnd()
18706 
 
18707 
  def write(self, oprot):
18708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18710 
      return
18711 
    oprot.writeStructBegin('updateShipmentAddress_args')
18712 
    if self.orderId is not None:
18713 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18714 
      oprot.writeI64(self.orderId)
18715 
      oprot.writeFieldEnd()
18716 
    if self.addressId is not None:
18717 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18718 
      oprot.writeI64(self.addressId)
18719 
      oprot.writeFieldEnd()
18720 
    oprot.writeFieldStop()
18721 
    oprot.writeStructEnd()
18722 
 
18723 
  def validate(self):
18724 
    return
18725 
 
18726 
 
18727 
  def __repr__(self):
18728 
    L = ['%s=%r' % (key, value)
18729 
      for key, value in self.__dict__.iteritems()]
18730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18731 
 
18732 
  def __eq__(self, other):
18733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18734 
 
18735 
  def __ne__(self, other):
18736 
    return not (self == other)
18737 
 
18738 
class updateShipmentAddress_result:
18739 
  """
18740 
  Attributes:
18741 
   - ex
18742 
  """
18743 
 
18744 
  thrift_spec = (
18745 
    None, # 0
18746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18747 
  )
18748 
 
18749 
  def __init__(self, ex=None,):
18750 
    self.ex = ex
18751 
 
18752 
  def read(self, iprot):
18753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18755 
      return
18756 
    iprot.readStructBegin()
18757 
    while True:
18758 
      (fname, ftype, fid) = iprot.readFieldBegin()
18759 
      if ftype == TType.STOP:
18760 
        break
18761 
      if fid == 1:
18762 
        if ftype == TType.STRUCT:
18763 
          self.ex = TransactionServiceException()
18764 
          self.ex.read(iprot)
18765 
        else:
18766 
          iprot.skip(ftype)
18767 
      else:
18768 
        iprot.skip(ftype)
18769 
      iprot.readFieldEnd()
18770 
    iprot.readStructEnd()
18771 
 
18772 
  def write(self, oprot):
18773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18775 
      return
18776 
    oprot.writeStructBegin('updateShipmentAddress_result')
18777 
    if self.ex is not None:
18778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18779 
      self.ex.write(oprot)
18780 
      oprot.writeFieldEnd()
18781 
    oprot.writeFieldStop()
18782 
    oprot.writeStructEnd()
18783 
 
18784 
  def validate(self):
18785 
    return
18786 
 
18787 
 
18788 
  def __repr__(self):
18789 
    L = ['%s=%r' % (key, value)
18790 
      for key, value in self.__dict__.iteritems()]
18791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18792 
 
18793 
  def __eq__(self, other):
18794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18795 
 
18796 
  def __ne__(self, other):
18797 
    return not (self == other)
18798 
 
4285 rajveer 18799 
class acceptOrdersForItemId_args:
18800 
  """
18801 
  Attributes:
18802 
   - itemId
18803 
   - inventory
18804 
  """
18805 
 
18806 
  thrift_spec = (
18807 
    None, # 0
18808 
    (1, TType.I64, 'itemId', None, None, ), # 1
18809 
    (2, TType.I64, 'inventory', None, None, ), # 2
18810 
  )
18811 
 
18812 
  def __init__(self, itemId=None, inventory=None,):
18813 
    self.itemId = itemId
18814 
    self.inventory = inventory
18815 
 
18816 
  def read(self, iprot):
18817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18819 
      return
18820 
    iprot.readStructBegin()
18821 
    while True:
18822 
      (fname, ftype, fid) = iprot.readFieldBegin()
18823 
      if ftype == TType.STOP:
18824 
        break
18825 
      if fid == 1:
18826 
        if ftype == TType.I64:
18827 
          self.itemId = iprot.readI64();
18828 
        else:
18829 
          iprot.skip(ftype)
18830 
      elif fid == 2:
18831 
        if ftype == TType.I64:
18832 
          self.inventory = iprot.readI64();
18833 
        else:
18834 
          iprot.skip(ftype)
18835 
      else:
18836 
        iprot.skip(ftype)
18837 
      iprot.readFieldEnd()
18838 
    iprot.readStructEnd()
18839 
 
18840 
  def write(self, oprot):
18841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18843 
      return
18844 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18845 
    if self.itemId is not None:
18846 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18847 
      oprot.writeI64(self.itemId)
18848 
      oprot.writeFieldEnd()
18849 
    if self.inventory is not None:
18850 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18851 
      oprot.writeI64(self.inventory)
18852 
      oprot.writeFieldEnd()
18853 
    oprot.writeFieldStop()
18854 
    oprot.writeStructEnd()
18855 
 
18856 
  def validate(self):
18857 
    return
18858 
 
18859 
 
18860 
  def __repr__(self):
18861 
    L = ['%s=%r' % (key, value)
18862 
      for key, value in self.__dict__.iteritems()]
18863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18864 
 
18865 
  def __eq__(self, other):
18866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18867 
 
18868 
  def __ne__(self, other):
18869 
    return not (self == other)
18870 
 
18871 
class acceptOrdersForItemId_result:
18872 
  """
18873 
  Attributes:
18874 
   - success
18875 
   - ex
18876 
  """
18877 
 
18878 
  thrift_spec = (
18879 
    (0, TType.BOOL, 'success', None, None, ), # 0
18880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18881 
  )
18882 
 
18883 
  def __init__(self, success=None, ex=None,):
18884 
    self.success = success
18885 
    self.ex = ex
18886 
 
18887 
  def read(self, iprot):
18888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18890 
      return
18891 
    iprot.readStructBegin()
18892 
    while True:
18893 
      (fname, ftype, fid) = iprot.readFieldBegin()
18894 
      if ftype == TType.STOP:
18895 
        break
18896 
      if fid == 0:
18897 
        if ftype == TType.BOOL:
18898 
          self.success = iprot.readBool();
18899 
        else:
18900 
          iprot.skip(ftype)
18901 
      elif fid == 1:
18902 
        if ftype == TType.STRUCT:
18903 
          self.ex = TransactionServiceException()
18904 
          self.ex.read(iprot)
18905 
        else:
18906 
          iprot.skip(ftype)
18907 
      else:
18908 
        iprot.skip(ftype)
18909 
      iprot.readFieldEnd()
18910 
    iprot.readStructEnd()
18911 
 
18912 
  def write(self, oprot):
18913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18915 
      return
18916 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18917 
    if self.success is not None:
18918 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18919 
      oprot.writeBool(self.success)
18920 
      oprot.writeFieldEnd()
18921 
    if self.ex is not None:
18922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18923 
      self.ex.write(oprot)
18924 
      oprot.writeFieldEnd()
18925 
    oprot.writeFieldStop()
18926 
    oprot.writeStructEnd()
18927 
 
18928 
  def validate(self):
18929 
    return
18930 
 
18931 
 
18932 
  def __repr__(self):
18933 
    L = ['%s=%r' % (key, value)
18934 
      for key, value in self.__dict__.iteritems()]
18935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18936 
 
18937 
  def __eq__(self, other):
18938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18939 
 
18940 
  def __ne__(self, other):
18941 
    return not (self == other)
4303 rajveer 18942 
 
18943 
class markOrdersAsPORaised_args:
18944 
  """
18945 
  Attributes:
18946 
   - vendorId
18947 
   - itemId
18948 
   - quantity
18949 
   - estimate
4369 rajveer 18950 
   - isReminder
4303 rajveer 18951 
  """
18952 
 
18953 
  thrift_spec = (
18954 
    None, # 0
18955 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18956 
    (2, TType.I64, 'itemId', None, None, ), # 2
18957 
    (3, TType.I64, 'quantity', None, None, ), # 3
18958 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18959 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18960 
  )
18961 
 
4369 rajveer 18962 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18963 
    self.vendorId = vendorId
18964 
    self.itemId = itemId
18965 
    self.quantity = quantity
18966 
    self.estimate = estimate
4369 rajveer 18967 
    self.isReminder = isReminder
4303 rajveer 18968 
 
18969 
  def read(self, iprot):
18970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18972 
      return
18973 
    iprot.readStructBegin()
18974 
    while True:
18975 
      (fname, ftype, fid) = iprot.readFieldBegin()
18976 
      if ftype == TType.STOP:
18977 
        break
18978 
      if fid == 1:
18979 
        if ftype == TType.I64:
18980 
          self.vendorId = iprot.readI64();
18981 
        else:
18982 
          iprot.skip(ftype)
18983 
      elif fid == 2:
18984 
        if ftype == TType.I64:
18985 
          self.itemId = iprot.readI64();
18986 
        else:
18987 
          iprot.skip(ftype)
18988 
      elif fid == 3:
18989 
        if ftype == TType.I64:
18990 
          self.quantity = iprot.readI64();
18991 
        else:
18992 
          iprot.skip(ftype)
18993 
      elif fid == 4:
18994 
        if ftype == TType.I64:
18995 
          self.estimate = iprot.readI64();
18996 
        else:
18997 
          iprot.skip(ftype)
4369 rajveer 18998 
      elif fid == 5:
18999 
        if ftype == TType.BOOL:
19000 
          self.isReminder = iprot.readBool();
19001 
        else:
19002 
          iprot.skip(ftype)
4303 rajveer 19003 
      else:
19004 
        iprot.skip(ftype)
19005 
      iprot.readFieldEnd()
19006 
    iprot.readStructEnd()
19007 
 
19008 
  def write(self, oprot):
19009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19011 
      return
19012 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19013 
    if self.vendorId is not None:
19014 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19015 
      oprot.writeI64(self.vendorId)
19016 
      oprot.writeFieldEnd()
19017 
    if self.itemId is not None:
19018 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19019 
      oprot.writeI64(self.itemId)
19020 
      oprot.writeFieldEnd()
19021 
    if self.quantity is not None:
19022 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19023 
      oprot.writeI64(self.quantity)
19024 
      oprot.writeFieldEnd()
19025 
    if self.estimate is not None:
19026 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19027 
      oprot.writeI64(self.estimate)
19028 
      oprot.writeFieldEnd()
4369 rajveer 19029 
    if self.isReminder is not None:
19030 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19031 
      oprot.writeBool(self.isReminder)
19032 
      oprot.writeFieldEnd()
4303 rajveer 19033 
    oprot.writeFieldStop()
19034 
    oprot.writeStructEnd()
19035 
 
19036 
  def validate(self):
19037 
    return
19038 
 
19039 
 
19040 
  def __repr__(self):
19041 
    L = ['%s=%r' % (key, value)
19042 
      for key, value in self.__dict__.iteritems()]
19043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19044 
 
19045 
  def __eq__(self, other):
19046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19047 
 
19048 
  def __ne__(self, other):
19049 
    return not (self == other)
19050 
 
19051 
class markOrdersAsPORaised_result:
19052 
  """
19053 
  Attributes:
19054 
   - ex
19055 
  """
19056 
 
19057 
  thrift_spec = (
19058 
    None, # 0
19059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19060 
  )
19061 
 
19062 
  def __init__(self, ex=None,):
19063 
    self.ex = ex
19064 
 
19065 
  def read(self, iprot):
19066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19068 
      return
19069 
    iprot.readStructBegin()
19070 
    while True:
19071 
      (fname, ftype, fid) = iprot.readFieldBegin()
19072 
      if ftype == TType.STOP:
19073 
        break
19074 
      if fid == 1:
19075 
        if ftype == TType.STRUCT:
19076 
          self.ex = TransactionServiceException()
19077 
          self.ex.read(iprot)
19078 
        else:
19079 
          iprot.skip(ftype)
19080 
      else:
19081 
        iprot.skip(ftype)
19082 
      iprot.readFieldEnd()
19083 
    iprot.readStructEnd()
19084 
 
19085 
  def write(self, oprot):
19086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19088 
      return
19089 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19090 
    if self.ex is not None:
19091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19092 
      self.ex.write(oprot)
19093 
      oprot.writeFieldEnd()
19094 
    oprot.writeFieldStop()
19095 
    oprot.writeStructEnd()
19096 
 
19097 
  def validate(self):
19098 
    return
19099 
 
19100 
 
19101 
  def __repr__(self):
19102 
    L = ['%s=%r' % (key, value)
19103 
      for key, value in self.__dict__.iteritems()]
19104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19105 
 
19106 
  def __eq__(self, other):
19107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19108 
 
19109 
  def __ne__(self, other):
19110 
    return not (self == other)
19111 
 
19112 
class markOrdersAsReversalInitiated_args:
19113 
  """
19114 
  Attributes:
19115 
   - vendorId
19116 
   - itemId
19117 
   - quantity
19118 
   - estimate
4369 rajveer 19119 
   - isReminder
4303 rajveer 19120 
  """
19121 
 
19122 
  thrift_spec = (
19123 
    None, # 0
19124 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19125 
    (2, TType.I64, 'itemId', None, None, ), # 2
19126 
    (3, TType.I64, 'quantity', None, None, ), # 3
19127 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19128 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19129 
  )
19130 
 
4369 rajveer 19131 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19132 
    self.vendorId = vendorId
19133 
    self.itemId = itemId
19134 
    self.quantity = quantity
19135 
    self.estimate = estimate
4369 rajveer 19136 
    self.isReminder = isReminder
4303 rajveer 19137 
 
19138 
  def read(self, iprot):
19139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19141 
      return
19142 
    iprot.readStructBegin()
19143 
    while True:
19144 
      (fname, ftype, fid) = iprot.readFieldBegin()
19145 
      if ftype == TType.STOP:
19146 
        break
19147 
      if fid == 1:
19148 
        if ftype == TType.I64:
19149 
          self.vendorId = iprot.readI64();
19150 
        else:
19151 
          iprot.skip(ftype)
19152 
      elif fid == 2:
19153 
        if ftype == TType.I64:
19154 
          self.itemId = iprot.readI64();
19155 
        else:
19156 
          iprot.skip(ftype)
19157 
      elif fid == 3:
19158 
        if ftype == TType.I64:
19159 
          self.quantity = iprot.readI64();
19160 
        else:
19161 
          iprot.skip(ftype)
19162 
      elif fid == 4:
19163 
        if ftype == TType.I64:
19164 
          self.estimate = iprot.readI64();
19165 
        else:
19166 
          iprot.skip(ftype)
4369 rajveer 19167 
      elif fid == 5:
19168 
        if ftype == TType.BOOL:
19169 
          self.isReminder = iprot.readBool();
19170 
        else:
19171 
          iprot.skip(ftype)
4303 rajveer 19172 
      else:
19173 
        iprot.skip(ftype)
19174 
      iprot.readFieldEnd()
19175 
    iprot.readStructEnd()
19176 
 
19177 
  def write(self, oprot):
19178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19180 
      return
19181 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19182 
    if self.vendorId is not None:
19183 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19184 
      oprot.writeI64(self.vendorId)
19185 
      oprot.writeFieldEnd()
19186 
    if self.itemId is not None:
19187 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19188 
      oprot.writeI64(self.itemId)
19189 
      oprot.writeFieldEnd()
19190 
    if self.quantity is not None:
19191 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19192 
      oprot.writeI64(self.quantity)
19193 
      oprot.writeFieldEnd()
19194 
    if self.estimate is not None:
19195 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19196 
      oprot.writeI64(self.estimate)
19197 
      oprot.writeFieldEnd()
4369 rajveer 19198 
    if self.isReminder is not None:
19199 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19200 
      oprot.writeBool(self.isReminder)
19201 
      oprot.writeFieldEnd()
4303 rajveer 19202 
    oprot.writeFieldStop()
19203 
    oprot.writeStructEnd()
19204 
 
19205 
  def validate(self):
19206 
    return
19207 
 
19208 
 
19209 
  def __repr__(self):
19210 
    L = ['%s=%r' % (key, value)
19211 
      for key, value in self.__dict__.iteritems()]
19212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19213 
 
19214 
  def __eq__(self, other):
19215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19216 
 
19217 
  def __ne__(self, other):
19218 
    return not (self == other)
19219 
 
19220 
class markOrdersAsReversalInitiated_result:
19221 
  """
19222 
  Attributes:
19223 
   - ex
19224 
  """
19225 
 
19226 
  thrift_spec = (
19227 
    None, # 0
19228 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19229 
  )
19230 
 
19231 
  def __init__(self, ex=None,):
19232 
    self.ex = ex
19233 
 
19234 
  def read(self, iprot):
19235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19237 
      return
19238 
    iprot.readStructBegin()
19239 
    while True:
19240 
      (fname, ftype, fid) = iprot.readFieldBegin()
19241 
      if ftype == TType.STOP:
19242 
        break
19243 
      if fid == 1:
19244 
        if ftype == TType.STRUCT:
19245 
          self.ex = TransactionServiceException()
19246 
          self.ex.read(iprot)
19247 
        else:
19248 
          iprot.skip(ftype)
19249 
      else:
19250 
        iprot.skip(ftype)
19251 
      iprot.readFieldEnd()
19252 
    iprot.readStructEnd()
19253 
 
19254 
  def write(self, oprot):
19255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19257 
      return
19258 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19259 
    if self.ex is not None:
19260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19261 
      self.ex.write(oprot)
19262 
      oprot.writeFieldEnd()
19263 
    oprot.writeFieldStop()
19264 
    oprot.writeStructEnd()
19265 
 
19266 
  def validate(self):
19267 
    return
19268 
 
19269 
 
19270 
  def __repr__(self):
19271 
    L = ['%s=%r' % (key, value)
19272 
      for key, value in self.__dict__.iteritems()]
19273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19274 
 
19275 
  def __eq__(self, other):
19276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19277 
 
19278 
  def __ne__(self, other):
19279 
    return not (self == other)
19280 
 
19281 
class markOrdersAsNotAvailabke_args:
19282 
  """
19283 
  Attributes:
19284 
   - vendorId
19285 
   - itemId
19286 
   - quantity
19287 
   - estimate
4369 rajveer 19288 
   - isReminder
4303 rajveer 19289 
  """
19290 
 
19291 
  thrift_spec = (
19292 
    None, # 0
19293 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19294 
    (2, TType.I64, 'itemId', None, None, ), # 2
19295 
    (3, TType.I64, 'quantity', None, None, ), # 3
19296 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19297 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19298 
  )
19299 
 
4369 rajveer 19300 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19301 
    self.vendorId = vendorId
19302 
    self.itemId = itemId
19303 
    self.quantity = quantity
19304 
    self.estimate = estimate
4369 rajveer 19305 
    self.isReminder = isReminder
4303 rajveer 19306 
 
19307 
  def read(self, iprot):
19308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19310 
      return
19311 
    iprot.readStructBegin()
19312 
    while True:
19313 
      (fname, ftype, fid) = iprot.readFieldBegin()
19314 
      if ftype == TType.STOP:
19315 
        break
19316 
      if fid == 1:
19317 
        if ftype == TType.I64:
19318 
          self.vendorId = iprot.readI64();
19319 
        else:
19320 
          iprot.skip(ftype)
19321 
      elif fid == 2:
19322 
        if ftype == TType.I64:
19323 
          self.itemId = iprot.readI64();
19324 
        else:
19325 
          iprot.skip(ftype)
19326 
      elif fid == 3:
19327 
        if ftype == TType.I64:
19328 
          self.quantity = iprot.readI64();
19329 
        else:
19330 
          iprot.skip(ftype)
19331 
      elif fid == 4:
19332 
        if ftype == TType.I64:
19333 
          self.estimate = iprot.readI64();
19334 
        else:
19335 
          iprot.skip(ftype)
4369 rajveer 19336 
      elif fid == 5:
19337 
        if ftype == TType.BOOL:
19338 
          self.isReminder = iprot.readBool();
19339 
        else:
19340 
          iprot.skip(ftype)
4303 rajveer 19341 
      else:
19342 
        iprot.skip(ftype)
19343 
      iprot.readFieldEnd()
19344 
    iprot.readStructEnd()
19345 
 
19346 
  def write(self, oprot):
19347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19349 
      return
19350 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19351 
    if self.vendorId is not None:
19352 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19353 
      oprot.writeI64(self.vendorId)
19354 
      oprot.writeFieldEnd()
19355 
    if self.itemId is not None:
19356 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19357 
      oprot.writeI64(self.itemId)
19358 
      oprot.writeFieldEnd()
19359 
    if self.quantity is not None:
19360 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19361 
      oprot.writeI64(self.quantity)
19362 
      oprot.writeFieldEnd()
19363 
    if self.estimate is not None:
19364 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19365 
      oprot.writeI64(self.estimate)
19366 
      oprot.writeFieldEnd()
4369 rajveer 19367 
    if self.isReminder is not None:
19368 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19369 
      oprot.writeBool(self.isReminder)
19370 
      oprot.writeFieldEnd()
4303 rajveer 19371 
    oprot.writeFieldStop()
19372 
    oprot.writeStructEnd()
19373 
 
19374 
  def validate(self):
19375 
    return
19376 
 
19377 
 
19378 
  def __repr__(self):
19379 
    L = ['%s=%r' % (key, value)
19380 
      for key, value in self.__dict__.iteritems()]
19381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19382 
 
19383 
  def __eq__(self, other):
19384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19385 
 
19386 
  def __ne__(self, other):
19387 
    return not (self == other)
19388 
 
19389 
class markOrdersAsNotAvailabke_result:
19390 
  """
19391 
  Attributes:
19392 
   - ex
19393 
  """
19394 
 
19395 
  thrift_spec = (
19396 
    None, # 0
19397 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19398 
  )
19399 
 
19400 
  def __init__(self, ex=None,):
19401 
    self.ex = ex
19402 
 
19403 
  def read(self, iprot):
19404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19406 
      return
19407 
    iprot.readStructBegin()
19408 
    while True:
19409 
      (fname, ftype, fid) = iprot.readFieldBegin()
19410 
      if ftype == TType.STOP:
19411 
        break
19412 
      if fid == 1:
19413 
        if ftype == TType.STRUCT:
19414 
          self.ex = TransactionServiceException()
19415 
          self.ex.read(iprot)
19416 
        else:
19417 
          iprot.skip(ftype)
19418 
      else:
19419 
        iprot.skip(ftype)
19420 
      iprot.readFieldEnd()
19421 
    iprot.readStructEnd()
19422 
 
19423 
  def write(self, oprot):
19424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19426 
      return
19427 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19428 
    if self.ex is not None:
19429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19430 
      self.ex.write(oprot)
19431 
      oprot.writeFieldEnd()
19432 
    oprot.writeFieldStop()
19433 
    oprot.writeStructEnd()
19434 
 
19435 
  def validate(self):
19436 
    return
19437 
 
19438 
 
19439 
  def __repr__(self):
19440 
    L = ['%s=%r' % (key, value)
19441 
      for key, value in self.__dict__.iteritems()]
19442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19443 
 
19444 
  def __eq__(self, other):
19445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19446 
 
19447 
  def __ne__(self, other):
19448 
    return not (self == other)
4369 rajveer 19449 
 
19450 
class markOrdersAsTimeout_args:
19451 
  """
19452 
  Attributes:
19453 
   - vendorId
19454 
  """
19455 
 
19456 
  thrift_spec = (
19457 
    None, # 0
19458 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19459 
  )
19460 
 
19461 
  def __init__(self, vendorId=None,):
19462 
    self.vendorId = vendorId
19463 
 
19464 
  def read(self, iprot):
19465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19467 
      return
19468 
    iprot.readStructBegin()
19469 
    while True:
19470 
      (fname, ftype, fid) = iprot.readFieldBegin()
19471 
      if ftype == TType.STOP:
19472 
        break
19473 
      if fid == 1:
19474 
        if ftype == TType.I64:
19475 
          self.vendorId = iprot.readI64();
19476 
        else:
19477 
          iprot.skip(ftype)
19478 
      else:
19479 
        iprot.skip(ftype)
19480 
      iprot.readFieldEnd()
19481 
    iprot.readStructEnd()
19482 
 
19483 
  def write(self, oprot):
19484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19486 
      return
19487 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19488 
    if self.vendorId is not None:
19489 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19490 
      oprot.writeI64(self.vendorId)
19491 
      oprot.writeFieldEnd()
19492 
    oprot.writeFieldStop()
19493 
    oprot.writeStructEnd()
19494 
 
19495 
  def validate(self):
19496 
    return
19497 
 
19498 
 
19499 
  def __repr__(self):
19500 
    L = ['%s=%r' % (key, value)
19501 
      for key, value in self.__dict__.iteritems()]
19502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19503 
 
19504 
  def __eq__(self, other):
19505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19506 
 
19507 
  def __ne__(self, other):
19508 
    return not (self == other)
19509 
 
19510 
class markOrdersAsTimeout_result:
19511 
  """
19512 
  Attributes:
19513 
   - success
19514 
   - ex
19515 
  """
19516 
 
19517 
  thrift_spec = (
19518 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19520 
  )
19521 
 
19522 
  def __init__(self, success=None, ex=None,):
19523 
    self.success = success
19524 
    self.ex = ex
19525 
 
19526 
  def read(self, iprot):
19527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19529 
      return
19530 
    iprot.readStructBegin()
19531 
    while True:
19532 
      (fname, ftype, fid) = iprot.readFieldBegin()
19533 
      if ftype == TType.STOP:
19534 
        break
19535 
      if fid == 0:
19536 
        if ftype == TType.MAP:
19537 
          self.success = {}
5411 rajveer 19538 
          (_ktype438, _vtype439, _size437 ) = iprot.readMapBegin()
19539 
          for _i441 in xrange(_size437):
19540 
            _key442 = iprot.readI32();
19541 
            _val443 = TimeoutSummary()
19542 
            _val443.read(iprot)
19543 
            self.success[_key442] = _val443
4369 rajveer 19544 
          iprot.readMapEnd()
19545 
        else:
19546 
          iprot.skip(ftype)
19547 
      elif fid == 1:
19548 
        if ftype == TType.STRUCT:
19549 
          self.ex = TransactionServiceException()
19550 
          self.ex.read(iprot)
19551 
        else:
19552 
          iprot.skip(ftype)
19553 
      else:
19554 
        iprot.skip(ftype)
19555 
      iprot.readFieldEnd()
19556 
    iprot.readStructEnd()
19557 
 
19558 
  def write(self, oprot):
19559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19561 
      return
19562 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19563 
    if self.success is not None:
19564 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19565 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5411 rajveer 19566 
      for kiter444,viter445 in self.success.items():
19567 
        oprot.writeI32(kiter444)
19568 
        viter445.write(oprot)
4369 rajveer 19569 
      oprot.writeMapEnd()
19570 
      oprot.writeFieldEnd()
19571 
    if self.ex is not None:
19572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19573 
      self.ex.write(oprot)
19574 
      oprot.writeFieldEnd()
19575 
    oprot.writeFieldStop()
19576 
    oprot.writeStructEnd()
19577 
 
19578 
  def validate(self):
19579 
    return
19580 
 
19581 
 
19582 
  def __repr__(self):
19583 
    L = ['%s=%r' % (key, value)
19584 
      for key, value in self.__dict__.iteritems()]
19585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19586 
 
19587 
  def __eq__(self, other):
19588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19589 
 
19590 
  def __ne__(self, other):
19591 
    return not (self == other)
4386 anupam.sin 19592 
 
4662 rajveer 19593 
class markOrderAsLostInTransit_args:
19594 
  """
19595 
  Attributes:
19596 
   - orderId
19597 
  """
19598 
 
19599 
  thrift_spec = (
19600 
    None, # 0
19601 
    (1, TType.I64, 'orderId', None, None, ), # 1
19602 
  )
19603 
 
19604 
  def __init__(self, orderId=None,):
19605 
    self.orderId = orderId
19606 
 
19607 
  def read(self, iprot):
19608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19610 
      return
19611 
    iprot.readStructBegin()
19612 
    while True:
19613 
      (fname, ftype, fid) = iprot.readFieldBegin()
19614 
      if ftype == TType.STOP:
19615 
        break
19616 
      if fid == 1:
19617 
        if ftype == TType.I64:
19618 
          self.orderId = iprot.readI64();
19619 
        else:
19620 
          iprot.skip(ftype)
19621 
      else:
19622 
        iprot.skip(ftype)
19623 
      iprot.readFieldEnd()
19624 
    iprot.readStructEnd()
19625 
 
19626 
  def write(self, oprot):
19627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19629 
      return
19630 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19631 
    if self.orderId is not None:
19632 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19633 
      oprot.writeI64(self.orderId)
19634 
      oprot.writeFieldEnd()
19635 
    oprot.writeFieldStop()
19636 
    oprot.writeStructEnd()
19637 
 
19638 
  def validate(self):
19639 
    return
19640 
 
19641 
 
19642 
  def __repr__(self):
19643 
    L = ['%s=%r' % (key, value)
19644 
      for key, value in self.__dict__.iteritems()]
19645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19646 
 
19647 
  def __eq__(self, other):
19648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19649 
 
19650 
  def __ne__(self, other):
19651 
    return not (self == other)
19652 
 
19653 
class markOrderAsLostInTransit_result:
19654 
  """
19655 
  Attributes:
19656 
   - success
19657 
   - ex
19658 
  """
19659 
 
19660 
  thrift_spec = (
19661 
    (0, TType.BOOL, 'success', None, None, ), # 0
19662 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19663 
  )
19664 
 
19665 
  def __init__(self, success=None, ex=None,):
19666 
    self.success = success
19667 
    self.ex = ex
19668 
 
19669 
  def read(self, iprot):
19670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19672 
      return
19673 
    iprot.readStructBegin()
19674 
    while True:
19675 
      (fname, ftype, fid) = iprot.readFieldBegin()
19676 
      if ftype == TType.STOP:
19677 
        break
19678 
      if fid == 0:
19679 
        if ftype == TType.BOOL:
19680 
          self.success = iprot.readBool();
19681 
        else:
19682 
          iprot.skip(ftype)
19683 
      elif fid == 1:
19684 
        if ftype == TType.STRUCT:
19685 
          self.ex = TransactionServiceException()
19686 
          self.ex.read(iprot)
19687 
        else:
19688 
          iprot.skip(ftype)
19689 
      else:
19690 
        iprot.skip(ftype)
19691 
      iprot.readFieldEnd()
19692 
    iprot.readStructEnd()
19693 
 
19694 
  def write(self, oprot):
19695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19697 
      return
19698 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19699 
    if self.success is not None:
19700 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19701 
      oprot.writeBool(self.success)
19702 
      oprot.writeFieldEnd()
19703 
    if self.ex is not None:
19704 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19705 
      self.ex.write(oprot)
19706 
      oprot.writeFieldEnd()
19707 
    oprot.writeFieldStop()
19708 
    oprot.writeStructEnd()
19709 
 
19710 
  def validate(self):
19711 
    return
19712 
 
19713 
 
19714 
  def __repr__(self):
19715 
    L = ['%s=%r' % (key, value)
19716 
      for key, value in self.__dict__.iteritems()]
19717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19718 
 
19719 
  def __eq__(self, other):
19720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19721 
 
19722 
  def __ne__(self, other):
19723 
    return not (self == other)
19724 
 
4386 anupam.sin 19725 
class getOrderForAwb_args:
19726 
  """
19727 
  Attributes:
19728 
   - awb
19729 
  """
19730 
 
19731 
  thrift_spec = (
19732 
    None, # 0
19733 
    (1, TType.STRING, 'awb', None, None, ), # 1
19734 
  )
19735 
 
19736 
  def __init__(self, awb=None,):
19737 
    self.awb = awb
19738 
 
19739 
  def read(self, iprot):
19740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19742 
      return
19743 
    iprot.readStructBegin()
19744 
    while True:
19745 
      (fname, ftype, fid) = iprot.readFieldBegin()
19746 
      if ftype == TType.STOP:
19747 
        break
19748 
      if fid == 1:
19749 
        if ftype == TType.STRING:
19750 
          self.awb = iprot.readString();
19751 
        else:
19752 
          iprot.skip(ftype)
19753 
      else:
19754 
        iprot.skip(ftype)
19755 
      iprot.readFieldEnd()
19756 
    iprot.readStructEnd()
19757 
 
19758 
  def write(self, oprot):
19759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19761 
      return
19762 
    oprot.writeStructBegin('getOrderForAwb_args')
19763 
    if self.awb is not None:
19764 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19765 
      oprot.writeString(self.awb)
19766 
      oprot.writeFieldEnd()
19767 
    oprot.writeFieldStop()
19768 
    oprot.writeStructEnd()
19769 
 
19770 
  def validate(self):
19771 
    return
19772 
 
19773 
 
19774 
  def __repr__(self):
19775 
    L = ['%s=%r' % (key, value)
19776 
      for key, value in self.__dict__.iteritems()]
19777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19778 
 
19779 
  def __eq__(self, other):
19780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19781 
 
19782 
  def __ne__(self, other):
19783 
    return not (self == other)
19784 
 
19785 
class getOrderForAwb_result:
19786 
  """
19787 
  Attributes:
19788 
   - success
19789 
   - ex
19790 
  """
19791 
 
19792 
  thrift_spec = (
19793 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19794 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19795 
  )
19796 
 
19797 
  def __init__(self, success=None, ex=None,):
19798 
    self.success = success
19799 
    self.ex = ex
19800 
 
19801 
  def read(self, iprot):
19802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19804 
      return
19805 
    iprot.readStructBegin()
19806 
    while True:
19807 
      (fname, ftype, fid) = iprot.readFieldBegin()
19808 
      if ftype == TType.STOP:
19809 
        break
19810 
      if fid == 0:
19811 
        if ftype == TType.STRUCT:
19812 
          self.success = Order()
19813 
          self.success.read(iprot)
19814 
        else:
19815 
          iprot.skip(ftype)
19816 
      elif fid == 1:
19817 
        if ftype == TType.STRUCT:
19818 
          self.ex = TransactionServiceException()
19819 
          self.ex.read(iprot)
19820 
        else:
19821 
          iprot.skip(ftype)
19822 
      else:
19823 
        iprot.skip(ftype)
19824 
      iprot.readFieldEnd()
19825 
    iprot.readStructEnd()
19826 
 
19827 
  def write(self, oprot):
19828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19830 
      return
19831 
    oprot.writeStructBegin('getOrderForAwb_result')
19832 
    if self.success is not None:
19833 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19834 
      self.success.write(oprot)
19835 
      oprot.writeFieldEnd()
19836 
    if self.ex is not None:
19837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19838 
      self.ex.write(oprot)
19839 
      oprot.writeFieldEnd()
19840 
    oprot.writeFieldStop()
19841 
    oprot.writeStructEnd()
19842 
 
19843 
  def validate(self):
19844 
    return
19845 
 
19846 
 
19847 
  def __repr__(self):
19848 
    L = ['%s=%r' % (key, value)
19849 
      for key, value in self.__dict__.iteritems()]
19850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19851 
 
19852 
  def __eq__(self, other):
19853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19854 
 
19855 
  def __ne__(self, other):
19856 
    return not (self == other)
4506 phani.kuma 19857 
 
19858 
class getOrdersForProviderForStatus_args:
19859 
  """
19860 
  Attributes:
19861 
   - logistics_provider_id
4910 phani.kuma 19862 
   - order_status_list
4506 phani.kuma 19863 
  """
19864 
 
19865 
  thrift_spec = (
19866 
    None, # 0
19867 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19868 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19869 
  )
19870 
 
4910 phani.kuma 19871 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19872 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19873 
    self.order_status_list = order_status_list
4506 phani.kuma 19874 
 
19875 
  def read(self, iprot):
19876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19878 
      return
19879 
    iprot.readStructBegin()
19880 
    while True:
19881 
      (fname, ftype, fid) = iprot.readFieldBegin()
19882 
      if ftype == TType.STOP:
19883 
        break
19884 
      if fid == 1:
19885 
        if ftype == TType.I64:
19886 
          self.logistics_provider_id = iprot.readI64();
19887 
        else:
19888 
          iprot.skip(ftype)
19889 
      elif fid == 2:
4910 phani.kuma 19890 
        if ftype == TType.LIST:
19891 
          self.order_status_list = []
5411 rajveer 19892 
          (_etype449, _size446) = iprot.readListBegin()
19893 
          for _i450 in xrange(_size446):
19894 
            _elem451 = iprot.readI32();
19895 
            self.order_status_list.append(_elem451)
4910 phani.kuma 19896 
          iprot.readListEnd()
4506 phani.kuma 19897 
        else:
19898 
          iprot.skip(ftype)
19899 
      else:
19900 
        iprot.skip(ftype)
19901 
      iprot.readFieldEnd()
19902 
    iprot.readStructEnd()
19903 
 
19904 
  def write(self, oprot):
19905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19907 
      return
19908 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19909 
    if self.logistics_provider_id is not None:
19910 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19911 
      oprot.writeI64(self.logistics_provider_id)
19912 
      oprot.writeFieldEnd()
4910 phani.kuma 19913 
    if self.order_status_list is not None:
19914 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19915 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5411 rajveer 19916 
      for iter452 in self.order_status_list:
19917 
        oprot.writeI32(iter452)
4910 phani.kuma 19918 
      oprot.writeListEnd()
4506 phani.kuma 19919 
      oprot.writeFieldEnd()
19920 
    oprot.writeFieldStop()
19921 
    oprot.writeStructEnd()
19922 
 
19923 
  def validate(self):
19924 
    return
19925 
 
19926 
 
19927 
  def __repr__(self):
19928 
    L = ['%s=%r' % (key, value)
19929 
      for key, value in self.__dict__.iteritems()]
19930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19931 
 
19932 
  def __eq__(self, other):
19933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19934 
 
19935 
  def __ne__(self, other):
19936 
    return not (self == other)
19937 
 
19938 
class getOrdersForProviderForStatus_result:
19939 
  """
19940 
  Attributes:
19941 
   - success
19942 
   - ex
19943 
  """
19944 
 
19945 
  thrift_spec = (
19946 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19948 
  )
19949 
 
19950 
  def __init__(self, success=None, ex=None,):
19951 
    self.success = success
19952 
    self.ex = ex
19953 
 
19954 
  def read(self, iprot):
19955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19957 
      return
19958 
    iprot.readStructBegin()
19959 
    while True:
19960 
      (fname, ftype, fid) = iprot.readFieldBegin()
19961 
      if ftype == TType.STOP:
19962 
        break
19963 
      if fid == 0:
19964 
        if ftype == TType.LIST:
19965 
          self.success = []
5411 rajveer 19966 
          (_etype456, _size453) = iprot.readListBegin()
19967 
          for _i457 in xrange(_size453):
19968 
            _elem458 = Order()
19969 
            _elem458.read(iprot)
19970 
            self.success.append(_elem458)
4506 phani.kuma 19971 
          iprot.readListEnd()
19972 
        else:
19973 
          iprot.skip(ftype)
19974 
      elif fid == 1:
19975 
        if ftype == TType.STRUCT:
19976 
          self.ex = TransactionServiceException()
19977 
          self.ex.read(iprot)
19978 
        else:
19979 
          iprot.skip(ftype)
19980 
      else:
19981 
        iprot.skip(ftype)
19982 
      iprot.readFieldEnd()
19983 
    iprot.readStructEnd()
19984 
 
19985 
  def write(self, oprot):
19986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19988 
      return
19989 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19990 
    if self.success is not None:
19991 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19992 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 19993 
      for iter459 in self.success:
19994 
        iter459.write(oprot)
4506 phani.kuma 19995 
      oprot.writeListEnd()
19996 
      oprot.writeFieldEnd()
19997 
    if self.ex is not None:
19998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19999 
      self.ex.write(oprot)
20000 
      oprot.writeFieldEnd()
20001 
    oprot.writeFieldStop()
20002 
    oprot.writeStructEnd()
20003 
 
20004 
  def validate(self):
20005 
    return
20006 
 
20007 
 
20008 
  def __repr__(self):
20009 
    L = ['%s=%r' % (key, value)
20010 
      for key, value in self.__dict__.iteritems()]
20011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20012 
 
20013 
  def __eq__(self, other):
20014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20015 
 
20016 
  def __ne__(self, other):
20017 
    return not (self == other)
4600 varun.gupt 20018 
 
20019 
class getBilledOrdersForVendor_args:
20020 
  """
20021 
  Attributes:
20022 
   - vendorId
20023 
   - billingDateFrom
20024 
   - billingDateTo
20025 
  """
20026 
 
20027 
  thrift_spec = (
20028 
    None, # 0
20029 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20030 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20031 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20032 
  )
20033 
 
20034 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20035 
    self.vendorId = vendorId
20036 
    self.billingDateFrom = billingDateFrom
20037 
    self.billingDateTo = billingDateTo
20038 
 
20039 
  def read(self, iprot):
20040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20042 
      return
20043 
    iprot.readStructBegin()
20044 
    while True:
20045 
      (fname, ftype, fid) = iprot.readFieldBegin()
20046 
      if ftype == TType.STOP:
20047 
        break
20048 
      if fid == 1:
20049 
        if ftype == TType.I64:
20050 
          self.vendorId = iprot.readI64();
20051 
        else:
20052 
          iprot.skip(ftype)
20053 
      elif fid == 2:
20054 
        if ftype == TType.I64:
20055 
          self.billingDateFrom = iprot.readI64();
20056 
        else:
20057 
          iprot.skip(ftype)
20058 
      elif fid == 3:
20059 
        if ftype == TType.I64:
20060 
          self.billingDateTo = iprot.readI64();
20061 
        else:
20062 
          iprot.skip(ftype)
20063 
      else:
20064 
        iprot.skip(ftype)
20065 
      iprot.readFieldEnd()
20066 
    iprot.readStructEnd()
20067 
 
20068 
  def write(self, oprot):
20069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20071 
      return
20072 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20073 
    if self.vendorId is not None:
20074 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20075 
      oprot.writeI64(self.vendorId)
20076 
      oprot.writeFieldEnd()
20077 
    if self.billingDateFrom is not None:
20078 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20079 
      oprot.writeI64(self.billingDateFrom)
20080 
      oprot.writeFieldEnd()
20081 
    if self.billingDateTo is not None:
20082 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20083 
      oprot.writeI64(self.billingDateTo)
20084 
      oprot.writeFieldEnd()
20085 
    oprot.writeFieldStop()
20086 
    oprot.writeStructEnd()
20087 
 
20088 
  def validate(self):
20089 
    return
20090 
 
20091 
 
20092 
  def __repr__(self):
20093 
    L = ['%s=%r' % (key, value)
20094 
      for key, value in self.__dict__.iteritems()]
20095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20096 
 
20097 
  def __eq__(self, other):
20098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20099 
 
20100 
  def __ne__(self, other):
20101 
    return not (self == other)
20102 
 
20103 
class getBilledOrdersForVendor_result:
20104 
  """
20105 
  Attributes:
20106 
   - success
20107 
   - ex
20108 
  """
20109 
 
20110 
  thrift_spec = (
20111 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20113 
  )
20114 
 
20115 
  def __init__(self, success=None, ex=None,):
20116 
    self.success = success
20117 
    self.ex = ex
20118 
 
20119 
  def read(self, iprot):
20120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20122 
      return
20123 
    iprot.readStructBegin()
20124 
    while True:
20125 
      (fname, ftype, fid) = iprot.readFieldBegin()
20126 
      if ftype == TType.STOP:
20127 
        break
20128 
      if fid == 0:
20129 
        if ftype == TType.LIST:
20130 
          self.success = []
5411 rajveer 20131 
          (_etype463, _size460) = iprot.readListBegin()
20132 
          for _i464 in xrange(_size460):
20133 
            _elem465 = Order()
20134 
            _elem465.read(iprot)
20135 
            self.success.append(_elem465)
4600 varun.gupt 20136 
          iprot.readListEnd()
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      elif fid == 1:
20140 
        if ftype == TType.STRUCT:
20141 
          self.ex = TransactionServiceException()
20142 
          self.ex.read(iprot)
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20155 
    if self.success is not None:
20156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20158 
      for iter466 in self.success:
20159 
        iter466.write(oprot)
4600 varun.gupt 20160 
      oprot.writeListEnd()
20161 
      oprot.writeFieldEnd()
20162 
    if self.ex is not None:
20163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20164 
      self.ex.write(oprot)
20165 
      oprot.writeFieldEnd()
20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
4607 rajveer 20184 
class getSlippedSippingDateOrders_args:
20185 
 
20186 
  thrift_spec = (
20187 
  )
20188 
 
20189 
  def read(self, iprot):
20190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20192 
      return
20193 
    iprot.readStructBegin()
20194 
    while True:
20195 
      (fname, ftype, fid) = iprot.readFieldBegin()
20196 
      if ftype == TType.STOP:
20197 
        break
20198 
      else:
20199 
        iprot.skip(ftype)
20200 
      iprot.readFieldEnd()
20201 
    iprot.readStructEnd()
20202 
 
20203 
  def write(self, oprot):
20204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20206 
      return
20207 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20208 
    oprot.writeFieldStop()
20209 
    oprot.writeStructEnd()
20210 
 
20211 
  def validate(self):
20212 
    return
20213 
 
20214 
 
20215 
  def __repr__(self):
20216 
    L = ['%s=%r' % (key, value)
20217 
      for key, value in self.__dict__.iteritems()]
20218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20219 
 
20220 
  def __eq__(self, other):
20221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20222 
 
20223 
  def __ne__(self, other):
20224 
    return not (self == other)
20225 
 
20226 
class getSlippedSippingDateOrders_result:
20227 
  """
20228 
  Attributes:
20229 
   - success
20230 
   - ex
20231 
  """
20232 
 
20233 
  thrift_spec = (
20234 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20236 
  )
20237 
 
20238 
  def __init__(self, success=None, ex=None,):
20239 
    self.success = success
20240 
    self.ex = ex
20241 
 
20242 
  def read(self, iprot):
20243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20245 
      return
20246 
    iprot.readStructBegin()
20247 
    while True:
20248 
      (fname, ftype, fid) = iprot.readFieldBegin()
20249 
      if ftype == TType.STOP:
20250 
        break
20251 
      if fid == 0:
20252 
        if ftype == TType.LIST:
20253 
          self.success = []
5411 rajveer 20254 
          (_etype470, _size467) = iprot.readListBegin()
20255 
          for _i471 in xrange(_size467):
20256 
            _elem472 = Order()
20257 
            _elem472.read(iprot)
20258 
            self.success.append(_elem472)
4607 rajveer 20259 
          iprot.readListEnd()
20260 
        else:
20261 
          iprot.skip(ftype)
20262 
      elif fid == 1:
20263 
        if ftype == TType.STRUCT:
20264 
          self.ex = TransactionServiceException()
20265 
          self.ex.read(iprot)
20266 
        else:
20267 
          iprot.skip(ftype)
20268 
      else:
20269 
        iprot.skip(ftype)
20270 
      iprot.readFieldEnd()
20271 
    iprot.readStructEnd()
20272 
 
20273 
  def write(self, oprot):
20274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20276 
      return
20277 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20278 
    if self.success is not None:
20279 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20280 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20281 
      for iter473 in self.success:
20282 
        iter473.write(oprot)
4607 rajveer 20283 
      oprot.writeListEnd()
20284 
      oprot.writeFieldEnd()
20285 
    if self.ex is not None:
20286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20287 
      self.ex.write(oprot)
20288 
      oprot.writeFieldEnd()
20289 
    oprot.writeFieldStop()
20290 
    oprot.writeStructEnd()
20291 
 
20292 
  def validate(self):
20293 
    return
20294 
 
20295 
 
20296 
  def __repr__(self):
20297 
    L = ['%s=%r' % (key, value)
20298 
      for key, value in self.__dict__.iteritems()]
20299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20300 
 
20301 
  def __eq__(self, other):
20302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20303 
 
20304 
  def __ne__(self, other):
20305 
    return not (self == other)
20306 
 
4709 rajveer 20307 
class getCancelledOrders_args:
20308 
  """
20309 
  Attributes:
20310 
   - cancelDateFrom
20311 
   - cancelDateTo
20312 
  """
20313 
 
20314 
  thrift_spec = (
20315 
    None, # 0
20316 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20317 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20318 
  )
20319 
 
20320 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20321 
    self.cancelDateFrom = cancelDateFrom
20322 
    self.cancelDateTo = cancelDateTo
20323 
 
20324 
  def read(self, iprot):
20325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20327 
      return
20328 
    iprot.readStructBegin()
20329 
    while True:
20330 
      (fname, ftype, fid) = iprot.readFieldBegin()
20331 
      if ftype == TType.STOP:
20332 
        break
20333 
      if fid == 1:
20334 
        if ftype == TType.I64:
20335 
          self.cancelDateFrom = iprot.readI64();
20336 
        else:
20337 
          iprot.skip(ftype)
20338 
      elif fid == 2:
20339 
        if ftype == TType.I64:
20340 
          self.cancelDateTo = iprot.readI64();
20341 
        else:
20342 
          iprot.skip(ftype)
20343 
      else:
20344 
        iprot.skip(ftype)
20345 
      iprot.readFieldEnd()
20346 
    iprot.readStructEnd()
20347 
 
20348 
  def write(self, oprot):
20349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20351 
      return
20352 
    oprot.writeStructBegin('getCancelledOrders_args')
20353 
    if self.cancelDateFrom is not None:
20354 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20355 
      oprot.writeI64(self.cancelDateFrom)
20356 
      oprot.writeFieldEnd()
20357 
    if self.cancelDateTo is not None:
20358 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20359 
      oprot.writeI64(self.cancelDateTo)
20360 
      oprot.writeFieldEnd()
20361 
    oprot.writeFieldStop()
20362 
    oprot.writeStructEnd()
20363 
 
20364 
  def validate(self):
20365 
    return
20366 
 
20367 
 
20368 
  def __repr__(self):
20369 
    L = ['%s=%r' % (key, value)
20370 
      for key, value in self.__dict__.iteritems()]
20371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20372 
 
20373 
  def __eq__(self, other):
20374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20375 
 
20376 
  def __ne__(self, other):
20377 
    return not (self == other)
20378 
 
20379 
class getCancelledOrders_result:
20380 
  """
20381 
  Attributes:
20382 
   - success
20383 
   - ex
20384 
  """
20385 
 
20386 
  thrift_spec = (
20387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20389 
  )
20390 
 
20391 
  def __init__(self, success=None, ex=None,):
20392 
    self.success = success
20393 
    self.ex = ex
20394 
 
20395 
  def read(self, iprot):
20396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20398 
      return
20399 
    iprot.readStructBegin()
20400 
    while True:
20401 
      (fname, ftype, fid) = iprot.readFieldBegin()
20402 
      if ftype == TType.STOP:
20403 
        break
20404 
      if fid == 0:
20405 
        if ftype == TType.LIST:
20406 
          self.success = []
5411 rajveer 20407 
          (_etype477, _size474) = iprot.readListBegin()
20408 
          for _i478 in xrange(_size474):
20409 
            _elem479 = Order()
20410 
            _elem479.read(iprot)
20411 
            self.success.append(_elem479)
4709 rajveer 20412 
          iprot.readListEnd()
20413 
        else:
20414 
          iprot.skip(ftype)
20415 
      elif fid == 1:
20416 
        if ftype == TType.STRUCT:
20417 
          self.ex = TransactionServiceException()
20418 
          self.ex.read(iprot)
20419 
        else:
20420 
          iprot.skip(ftype)
20421 
      else:
20422 
        iprot.skip(ftype)
20423 
      iprot.readFieldEnd()
20424 
    iprot.readStructEnd()
20425 
 
20426 
  def write(self, oprot):
20427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20429 
      return
20430 
    oprot.writeStructBegin('getCancelledOrders_result')
20431 
    if self.success is not None:
20432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20434 
      for iter480 in self.success:
20435 
        iter480.write(oprot)
4709 rajveer 20436 
      oprot.writeListEnd()
20437 
      oprot.writeFieldEnd()
20438 
    if self.ex is not None:
20439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20440 
      self.ex.write(oprot)
20441 
      oprot.writeFieldEnd()
20442 
    oprot.writeFieldStop()
20443 
    oprot.writeStructEnd()
20444 
 
20445 
  def validate(self):
20446 
    return
20447 
 
20448 
 
20449 
  def __repr__(self):
20450 
    L = ['%s=%r' % (key, value)
20451 
      for key, value in self.__dict__.iteritems()]
20452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20453 
 
20454 
  def __eq__(self, other):
20455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20456 
 
20457 
  def __ne__(self, other):
20458 
    return not (self == other)
20459 
 
4600 varun.gupt 20460 
class saveBluedartSettlements_args:
20461 
  """
20462 
  Attributes:
20463 
   - mapAWBAndAmount
20464 
  """
20465 
 
20466 
  thrift_spec = (
20467 
    None, # 0
20468 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20469 
  )
20470 
 
20471 
  def __init__(self, mapAWBAndAmount=None,):
20472 
    self.mapAWBAndAmount = mapAWBAndAmount
20473 
 
20474 
  def read(self, iprot):
20475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20477 
      return
20478 
    iprot.readStructBegin()
20479 
    while True:
20480 
      (fname, ftype, fid) = iprot.readFieldBegin()
20481 
      if ftype == TType.STOP:
20482 
        break
20483 
      if fid == 1:
20484 
        if ftype == TType.MAP:
20485 
          self.mapAWBAndAmount = {}
5411 rajveer 20486 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
20487 
          for _i485 in xrange(_size481):
20488 
            _key486 = iprot.readI64();
20489 
            _val487 = iprot.readDouble();
20490 
            self.mapAWBAndAmount[_key486] = _val487
4600 varun.gupt 20491 
          iprot.readMapEnd()
20492 
        else:
20493 
          iprot.skip(ftype)
20494 
      else:
20495 
        iprot.skip(ftype)
20496 
      iprot.readFieldEnd()
20497 
    iprot.readStructEnd()
20498 
 
20499 
  def write(self, oprot):
20500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20502 
      return
20503 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20504 
    if self.mapAWBAndAmount is not None:
20505 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20506 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5411 rajveer 20507 
      for kiter488,viter489 in self.mapAWBAndAmount.items():
20508 
        oprot.writeI64(kiter488)
20509 
        oprot.writeDouble(viter489)
4600 varun.gupt 20510 
      oprot.writeMapEnd()
20511 
      oprot.writeFieldEnd()
20512 
    oprot.writeFieldStop()
20513 
    oprot.writeStructEnd()
20514 
 
20515 
  def validate(self):
20516 
    return
20517 
 
20518 
 
20519 
  def __repr__(self):
20520 
    L = ['%s=%r' % (key, value)
20521 
      for key, value in self.__dict__.iteritems()]
20522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20523 
 
20524 
  def __eq__(self, other):
20525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20526 
 
20527 
  def __ne__(self, other):
20528 
    return not (self == other)
20529 
 
20530 
class saveBluedartSettlements_result:
20531 
  """
20532 
  Attributes:
20533 
   - ex
20534 
  """
20535 
 
20536 
  thrift_spec = (
20537 
    None, # 0
20538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20539 
  )
20540 
 
20541 
  def __init__(self, ex=None,):
20542 
    self.ex = ex
20543 
 
20544 
  def read(self, iprot):
20545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20547 
      return
20548 
    iprot.readStructBegin()
20549 
    while True:
20550 
      (fname, ftype, fid) = iprot.readFieldBegin()
20551 
      if ftype == TType.STOP:
20552 
        break
20553 
      if fid == 1:
20554 
        if ftype == TType.STRUCT:
20555 
          self.ex = TransactionServiceException()
20556 
          self.ex.read(iprot)
20557 
        else:
20558 
          iprot.skip(ftype)
20559 
      else:
20560 
        iprot.skip(ftype)
20561 
      iprot.readFieldEnd()
20562 
    iprot.readStructEnd()
20563 
 
20564 
  def write(self, oprot):
20565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20567 
      return
20568 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20569 
    if self.ex is not None:
20570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20571 
      self.ex.write(oprot)
20572 
      oprot.writeFieldEnd()
20573 
    oprot.writeFieldStop()
20574 
    oprot.writeStructEnd()
20575 
 
20576 
  def validate(self):
20577 
    return
20578 
 
20579 
 
20580 
  def __repr__(self):
20581 
    L = ['%s=%r' % (key, value)
20582 
      for key, value in self.__dict__.iteritems()]
20583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20584 
 
20585 
  def __eq__(self, other):
20586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20587 
 
20588 
  def __ne__(self, other):
20589 
    return not (self == other)
20590 
 
20591 
class savePaymentSettlements_args:
20592 
  """
20593 
  Attributes:
20594 
   - settlementDate
20595 
   - paymentGatewayId
4905 varun.gupt 20596 
   - referenceId
4600 varun.gupt 20597 
   - serviceTax
20598 
   - otherCharges
20599 
   - netCollection
20600 
  """
20601 
 
20602 
  thrift_spec = (
20603 
    None, # 0
20604 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20605 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20606 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20607 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20608 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20609 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20610 
  )
20611 
 
4905 varun.gupt 20612 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20613 
    self.settlementDate = settlementDate
20614 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20615 
    self.referenceId = referenceId
4600 varun.gupt 20616 
    self.serviceTax = serviceTax
20617 
    self.otherCharges = otherCharges
20618 
    self.netCollection = netCollection
20619 
 
20620 
  def read(self, iprot):
20621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20623 
      return
20624 
    iprot.readStructBegin()
20625 
    while True:
20626 
      (fname, ftype, fid) = iprot.readFieldBegin()
20627 
      if ftype == TType.STOP:
20628 
        break
20629 
      if fid == 1:
20630 
        if ftype == TType.I64:
20631 
          self.settlementDate = iprot.readI64();
20632 
        else:
20633 
          iprot.skip(ftype)
20634 
      elif fid == 2:
20635 
        if ftype == TType.I64:
20636 
          self.paymentGatewayId = iprot.readI64();
20637 
        else:
20638 
          iprot.skip(ftype)
20639 
      elif fid == 3:
20640 
        if ftype == TType.I64:
4905 varun.gupt 20641 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20642 
        else:
20643 
          iprot.skip(ftype)
20644 
      elif fid == 4:
20645 
        if ftype == TType.DOUBLE:
20646 
          self.serviceTax = iprot.readDouble();
20647 
        else:
20648 
          iprot.skip(ftype)
20649 
      elif fid == 5:
20650 
        if ftype == TType.DOUBLE:
20651 
          self.otherCharges = iprot.readDouble();
20652 
        else:
20653 
          iprot.skip(ftype)
20654 
      elif fid == 6:
20655 
        if ftype == TType.DOUBLE:
20656 
          self.netCollection = iprot.readDouble();
20657 
        else:
20658 
          iprot.skip(ftype)
20659 
      else:
20660 
        iprot.skip(ftype)
20661 
      iprot.readFieldEnd()
20662 
    iprot.readStructEnd()
20663 
 
20664 
  def write(self, oprot):
20665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20667 
      return
20668 
    oprot.writeStructBegin('savePaymentSettlements_args')
20669 
    if self.settlementDate is not None:
20670 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20671 
      oprot.writeI64(self.settlementDate)
20672 
      oprot.writeFieldEnd()
20673 
    if self.paymentGatewayId is not None:
20674 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20675 
      oprot.writeI64(self.paymentGatewayId)
20676 
      oprot.writeFieldEnd()
4905 varun.gupt 20677 
    if self.referenceId is not None:
20678 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20679 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20680 
      oprot.writeFieldEnd()
20681 
    if self.serviceTax is not None:
20682 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20683 
      oprot.writeDouble(self.serviceTax)
20684 
      oprot.writeFieldEnd()
20685 
    if self.otherCharges is not None:
20686 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20687 
      oprot.writeDouble(self.otherCharges)
20688 
      oprot.writeFieldEnd()
20689 
    if self.netCollection is not None:
20690 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20691 
      oprot.writeDouble(self.netCollection)
20692 
      oprot.writeFieldEnd()
20693 
    oprot.writeFieldStop()
20694 
    oprot.writeStructEnd()
20695 
 
20696 
  def validate(self):
20697 
    return
20698 
 
20699 
 
20700 
  def __repr__(self):
20701 
    L = ['%s=%r' % (key, value)
20702 
      for key, value in self.__dict__.iteritems()]
20703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20704 
 
20705 
  def __eq__(self, other):
20706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20707 
 
20708 
  def __ne__(self, other):
20709 
    return not (self == other)
20710 
 
20711 
class savePaymentSettlements_result:
20712 
  """
20713 
  Attributes:
20714 
   - ex
20715 
  """
20716 
 
20717 
  thrift_spec = (
20718 
    None, # 0
20719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20720 
  )
20721 
 
20722 
  def __init__(self, ex=None,):
20723 
    self.ex = ex
20724 
 
20725 
  def read(self, iprot):
20726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20728 
      return
20729 
    iprot.readStructBegin()
20730 
    while True:
20731 
      (fname, ftype, fid) = iprot.readFieldBegin()
20732 
      if ftype == TType.STOP:
20733 
        break
20734 
      if fid == 1:
20735 
        if ftype == TType.STRUCT:
20736 
          self.ex = TransactionServiceException()
20737 
          self.ex.read(iprot)
20738 
        else:
20739 
          iprot.skip(ftype)
20740 
      else:
20741 
        iprot.skip(ftype)
20742 
      iprot.readFieldEnd()
20743 
    iprot.readStructEnd()
20744 
 
20745 
  def write(self, oprot):
20746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20748 
      return
20749 
    oprot.writeStructBegin('savePaymentSettlements_result')
20750 
    if self.ex is not None:
20751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20752 
      self.ex.write(oprot)
20753 
      oprot.writeFieldEnd()
20754 
    oprot.writeFieldStop()
20755 
    oprot.writeStructEnd()
20756 
 
20757 
  def validate(self):
20758 
    return
20759 
 
20760 
 
20761 
  def __repr__(self):
20762 
    L = ['%s=%r' % (key, value)
20763 
      for key, value in self.__dict__.iteritems()]
20764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20765 
 
20766 
  def __eq__(self, other):
20767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20768 
 
20769 
  def __ne__(self, other):
20770 
    return not (self == other)
20771 
 
20772 
class saveEBSSettlementSummary_args:
20773 
  """
20774 
  Attributes:
20775 
   - settlementId
20776 
   - settlementDate
20777 
   - transactionDateFrom
20778 
   - transactionDateTo
20779 
   - amount
20780 
  """
20781 
 
20782 
  thrift_spec = (
20783 
    None, # 0
20784 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20785 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20786 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20787 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20788 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20789 
  )
20790 
 
20791 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20792 
    self.settlementId = settlementId
20793 
    self.settlementDate = settlementDate
20794 
    self.transactionDateFrom = transactionDateFrom
20795 
    self.transactionDateTo = transactionDateTo
20796 
    self.amount = amount
20797 
 
20798 
  def read(self, iprot):
20799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20801 
      return
20802 
    iprot.readStructBegin()
20803 
    while True:
20804 
      (fname, ftype, fid) = iprot.readFieldBegin()
20805 
      if ftype == TType.STOP:
20806 
        break
20807 
      if fid == 1:
20808 
        if ftype == TType.I64:
20809 
          self.settlementId = iprot.readI64();
20810 
        else:
20811 
          iprot.skip(ftype)
20812 
      elif fid == 2:
20813 
        if ftype == TType.I64:
20814 
          self.settlementDate = iprot.readI64();
20815 
        else:
20816 
          iprot.skip(ftype)
20817 
      elif fid == 3:
20818 
        if ftype == TType.I64:
20819 
          self.transactionDateFrom = iprot.readI64();
20820 
        else:
20821 
          iprot.skip(ftype)
20822 
      elif fid == 4:
20823 
        if ftype == TType.I64:
20824 
          self.transactionDateTo = iprot.readI64();
20825 
        else:
20826 
          iprot.skip(ftype)
20827 
      elif fid == 5:
20828 
        if ftype == TType.DOUBLE:
20829 
          self.amount = iprot.readDouble();
20830 
        else:
20831 
          iprot.skip(ftype)
20832 
      else:
20833 
        iprot.skip(ftype)
20834 
      iprot.readFieldEnd()
20835 
    iprot.readStructEnd()
20836 
 
20837 
  def write(self, oprot):
20838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20840 
      return
20841 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20842 
    if self.settlementId is not None:
20843 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20844 
      oprot.writeI64(self.settlementId)
20845 
      oprot.writeFieldEnd()
20846 
    if self.settlementDate is not None:
20847 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20848 
      oprot.writeI64(self.settlementDate)
20849 
      oprot.writeFieldEnd()
20850 
    if self.transactionDateFrom is not None:
20851 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20852 
      oprot.writeI64(self.transactionDateFrom)
20853 
      oprot.writeFieldEnd()
20854 
    if self.transactionDateTo is not None:
20855 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20856 
      oprot.writeI64(self.transactionDateTo)
20857 
      oprot.writeFieldEnd()
20858 
    if self.amount is not None:
20859 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20860 
      oprot.writeDouble(self.amount)
20861 
      oprot.writeFieldEnd()
20862 
    oprot.writeFieldStop()
20863 
    oprot.writeStructEnd()
20864 
 
20865 
  def validate(self):
20866 
    return
20867 
 
20868 
 
20869 
  def __repr__(self):
20870 
    L = ['%s=%r' % (key, value)
20871 
      for key, value in self.__dict__.iteritems()]
20872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20873 
 
20874 
  def __eq__(self, other):
20875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20876 
 
20877 
  def __ne__(self, other):
20878 
    return not (self == other)
20879 
 
20880 
class saveEBSSettlementSummary_result:
20881 
  """
20882 
  Attributes:
20883 
   - ex
20884 
  """
20885 
 
20886 
  thrift_spec = (
20887 
    None, # 0
20888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20889 
  )
20890 
 
20891 
  def __init__(self, ex=None,):
20892 
    self.ex = ex
20893 
 
20894 
  def read(self, iprot):
20895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20897 
      return
20898 
    iprot.readStructBegin()
20899 
    while True:
20900 
      (fname, ftype, fid) = iprot.readFieldBegin()
20901 
      if ftype == TType.STOP:
20902 
        break
20903 
      if fid == 1:
20904 
        if ftype == TType.STRUCT:
20905 
          self.ex = TransactionServiceException()
20906 
          self.ex.read(iprot)
20907 
        else:
20908 
          iprot.skip(ftype)
20909 
      else:
20910 
        iprot.skip(ftype)
20911 
      iprot.readFieldEnd()
20912 
    iprot.readStructEnd()
20913 
 
20914 
  def write(self, oprot):
20915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20917 
      return
20918 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20919 
    if self.ex is not None:
20920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20921 
      self.ex.write(oprot)
20922 
      oprot.writeFieldEnd()
20923 
    oprot.writeFieldStop()
20924 
    oprot.writeStructEnd()
20925 
 
20926 
  def validate(self):
20927 
    return
20928 
 
20929 
 
20930 
  def __repr__(self):
20931 
    L = ['%s=%r' % (key, value)
20932 
      for key, value in self.__dict__.iteritems()]
20933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20934 
 
20935 
  def __eq__(self, other):
20936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20937 
 
20938 
  def __ne__(self, other):
20939 
    return not (self == other)
20940 
 
5386 phani.kuma 20941 
class getSettlementForPrepaid_args:
4600 varun.gupt 20942 
  """
20943 
  Attributes:
5189 varun.gupt 20944 
   - referenceId
20945 
   - isRefund
4600 varun.gupt 20946 
  """
20947 
 
20948 
  thrift_spec = (
20949 
    None, # 0
5189 varun.gupt 20950 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 20951 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20952 
  )
20953 
 
5386 phani.kuma 20954 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 20955 
    self.referenceId = referenceId
20956 
    self.isRefund = isRefund
4600 varun.gupt 20957 
 
20958 
  def read(self, iprot):
20959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20961 
      return
20962 
    iprot.readStructBegin()
20963 
    while True:
20964 
      (fname, ftype, fid) = iprot.readFieldBegin()
20965 
      if ftype == TType.STOP:
20966 
        break
20967 
      if fid == 1:
20968 
        if ftype == TType.I64:
5189 varun.gupt 20969 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20970 
        else:
20971 
          iprot.skip(ftype)
5189 varun.gupt 20972 
      elif fid == 2:
20973 
        if ftype == TType.BOOL:
20974 
          self.isRefund = iprot.readBool();
20975 
        else:
20976 
          iprot.skip(ftype)
4600 varun.gupt 20977 
      else:
20978 
        iprot.skip(ftype)
20979 
      iprot.readFieldEnd()
20980 
    iprot.readStructEnd()
20981 
 
20982 
  def write(self, oprot):
20983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20985 
      return
5386 phani.kuma 20986 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 20987 
    if self.referenceId is not None:
20988 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20989 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20990 
      oprot.writeFieldEnd()
5386 phani.kuma 20991 
    if self.isRefund is not None:
20992 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20993 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 20994 
      oprot.writeFieldEnd()
5386 phani.kuma 20995 
    oprot.writeFieldStop()
20996 
    oprot.writeStructEnd()
20997 
 
20998 
  def validate(self):
20999 
    return
21000 
 
21001 
 
21002 
  def __repr__(self):
21003 
    L = ['%s=%r' % (key, value)
21004 
      for key, value in self.__dict__.iteritems()]
21005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21006 
 
21007 
  def __eq__(self, other):
21008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21009 
 
21010 
  def __ne__(self, other):
21011 
    return not (self == other)
21012 
 
21013 
class getSettlementForPrepaid_result:
21014 
  """
21015 
  Attributes:
21016 
   - success
21017 
   - ex
21018 
  """
21019 
 
21020 
  thrift_spec = (
21021 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21023 
  )
21024 
 
21025 
  def __init__(self, success=None, ex=None,):
21026 
    self.success = success
21027 
    self.ex = ex
21028 
 
21029 
  def read(self, iprot):
21030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21032 
      return
21033 
    iprot.readStructBegin()
21034 
    while True:
21035 
      (fname, ftype, fid) = iprot.readFieldBegin()
21036 
      if ftype == TType.STOP:
21037 
        break
21038 
      if fid == 0:
21039 
        if ftype == TType.STRUCT:
21040 
          self.success = PaymentSettlement()
21041 
          self.success.read(iprot)
21042 
        else:
21043 
          iprot.skip(ftype)
21044 
      elif fid == 1:
21045 
        if ftype == TType.STRUCT:
21046 
          self.ex = TransactionServiceException()
21047 
          self.ex.read(iprot)
21048 
        else:
21049 
          iprot.skip(ftype)
21050 
      else:
21051 
        iprot.skip(ftype)
21052 
      iprot.readFieldEnd()
21053 
    iprot.readStructEnd()
21054 
 
21055 
  def write(self, oprot):
21056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21058 
      return
21059 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21060 
    if self.success is not None:
21061 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21062 
      self.success.write(oprot)
21063 
      oprot.writeFieldEnd()
21064 
    if self.ex is not None:
21065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21066 
      self.ex.write(oprot)
21067 
      oprot.writeFieldEnd()
21068 
    oprot.writeFieldStop()
21069 
    oprot.writeStructEnd()
21070 
 
21071 
  def validate(self):
21072 
    return
21073 
 
21074 
 
21075 
  def __repr__(self):
21076 
    L = ['%s=%r' % (key, value)
21077 
      for key, value in self.__dict__.iteritems()]
21078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21079 
 
21080 
  def __eq__(self, other):
21081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21082 
 
21083 
  def __ne__(self, other):
21084 
    return not (self == other)
21085 
 
21086 
class getSettlementForCod_args:
21087 
  """
21088 
  Attributes:
21089 
   - orderId
21090 
   - isRefund
21091 
  """
21092 
 
21093 
  thrift_spec = (
21094 
    None, # 0
21095 
    (1, TType.I64, 'orderId', None, None, ), # 1
21096 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21097 
  )
21098 
 
21099 
  def __init__(self, orderId=None, isRefund=None,):
21100 
    self.orderId = orderId
21101 
    self.isRefund = isRefund
21102 
 
21103 
  def read(self, iprot):
21104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21106 
      return
21107 
    iprot.readStructBegin()
21108 
    while True:
21109 
      (fname, ftype, fid) = iprot.readFieldBegin()
21110 
      if ftype == TType.STOP:
21111 
        break
21112 
      if fid == 1:
21113 
        if ftype == TType.I64:
21114 
          self.orderId = iprot.readI64();
21115 
        else:
21116 
          iprot.skip(ftype)
21117 
      elif fid == 2:
21118 
        if ftype == TType.BOOL:
21119 
          self.isRefund = iprot.readBool();
21120 
        else:
21121 
          iprot.skip(ftype)
21122 
      else:
21123 
        iprot.skip(ftype)
21124 
      iprot.readFieldEnd()
21125 
    iprot.readStructEnd()
21126 
 
21127 
  def write(self, oprot):
21128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21130 
      return
21131 
    oprot.writeStructBegin('getSettlementForCod_args')
21132 
    if self.orderId is not None:
21133 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21134 
      oprot.writeI64(self.orderId)
21135 
      oprot.writeFieldEnd()
5189 varun.gupt 21136 
    if self.isRefund is not None:
5386 phani.kuma 21137 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21138 
      oprot.writeBool(self.isRefund)
21139 
      oprot.writeFieldEnd()
4600 varun.gupt 21140 
    oprot.writeFieldStop()
21141 
    oprot.writeStructEnd()
21142 
 
21143 
  def validate(self):
21144 
    return
21145 
 
21146 
 
21147 
  def __repr__(self):
21148 
    L = ['%s=%r' % (key, value)
21149 
      for key, value in self.__dict__.iteritems()]
21150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21151 
 
21152 
  def __eq__(self, other):
21153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21154 
 
21155 
  def __ne__(self, other):
21156 
    return not (self == other)
21157 
 
5386 phani.kuma 21158 
class getSettlementForCod_result:
4600 varun.gupt 21159 
  """
21160 
  Attributes:
21161 
   - success
21162 
   - ex
21163 
  """
21164 
 
21165 
  thrift_spec = (
21166 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21168 
  )
21169 
 
21170 
  def __init__(self, success=None, ex=None,):
21171 
    self.success = success
21172 
    self.ex = ex
21173 
 
21174 
  def read(self, iprot):
21175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21177 
      return
21178 
    iprot.readStructBegin()
21179 
    while True:
21180 
      (fname, ftype, fid) = iprot.readFieldBegin()
21181 
      if ftype == TType.STOP:
21182 
        break
21183 
      if fid == 0:
21184 
        if ftype == TType.STRUCT:
21185 
          self.success = PaymentSettlement()
21186 
          self.success.read(iprot)
21187 
        else:
21188 
          iprot.skip(ftype)
21189 
      elif fid == 1:
21190 
        if ftype == TType.STRUCT:
21191 
          self.ex = TransactionServiceException()
21192 
          self.ex.read(iprot)
21193 
        else:
21194 
          iprot.skip(ftype)
21195 
      else:
21196 
        iprot.skip(ftype)
21197 
      iprot.readFieldEnd()
21198 
    iprot.readStructEnd()
21199 
 
21200 
  def write(self, oprot):
21201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21203 
      return
5386 phani.kuma 21204 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21205 
    if self.success is not None:
21206 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21207 
      self.success.write(oprot)
21208 
      oprot.writeFieldEnd()
21209 
    if self.ex is not None:
21210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21211 
      self.ex.write(oprot)
21212 
      oprot.writeFieldEnd()
21213 
    oprot.writeFieldStop()
21214 
    oprot.writeStructEnd()
21215 
 
21216 
  def validate(self):
21217 
    return
21218 
 
21219 
 
21220 
  def __repr__(self):
21221 
    L = ['%s=%r' % (key, value)
21222 
      for key, value in self.__dict__.iteritems()]
21223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21224 
 
21225 
  def __eq__(self, other):
21226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21227 
 
21228 
  def __ne__(self, other):
21229 
    return not (self == other)
21230 
 
21231 
class getEBSSettlementSummaries_args:
21232 
 
21233 
  thrift_spec = (
21234 
  )
21235 
 
21236 
  def read(self, iprot):
21237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21239 
      return
21240 
    iprot.readStructBegin()
21241 
    while True:
21242 
      (fname, ftype, fid) = iprot.readFieldBegin()
21243 
      if ftype == TType.STOP:
21244 
        break
21245 
      else:
21246 
        iprot.skip(ftype)
21247 
      iprot.readFieldEnd()
21248 
    iprot.readStructEnd()
21249 
 
21250 
  def write(self, oprot):
21251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21253 
      return
21254 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21255 
    oprot.writeFieldStop()
21256 
    oprot.writeStructEnd()
21257 
 
21258 
  def validate(self):
21259 
    return
21260 
 
21261 
 
21262 
  def __repr__(self):
21263 
    L = ['%s=%r' % (key, value)
21264 
      for key, value in self.__dict__.iteritems()]
21265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21266 
 
21267 
  def __eq__(self, other):
21268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21269 
 
21270 
  def __ne__(self, other):
21271 
    return not (self == other)
21272 
 
21273 
class getEBSSettlementSummaries_result:
21274 
  """
21275 
  Attributes:
21276 
   - success
21277 
   - ex
21278 
  """
21279 
 
21280 
  thrift_spec = (
21281 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21283 
  )
21284 
 
21285 
  def __init__(self, success=None, ex=None,):
21286 
    self.success = success
21287 
    self.ex = ex
21288 
 
21289 
  def read(self, iprot):
21290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21292 
      return
21293 
    iprot.readStructBegin()
21294 
    while True:
21295 
      (fname, ftype, fid) = iprot.readFieldBegin()
21296 
      if ftype == TType.STOP:
21297 
        break
21298 
      if fid == 0:
21299 
        if ftype == TType.MAP:
21300 
          self.success = {}
5411 rajveer 21301 
          (_ktype491, _vtype492, _size490 ) = iprot.readMapBegin()
21302 
          for _i494 in xrange(_size490):
21303 
            _key495 = iprot.readI64();
21304 
            _val496 = iprot.readString();
21305 
            self.success[_key495] = _val496
4600 varun.gupt 21306 
          iprot.readMapEnd()
21307 
        else:
21308 
          iprot.skip(ftype)
21309 
      elif fid == 1:
21310 
        if ftype == TType.STRUCT:
21311 
          self.ex = TransactionServiceException()
21312 
          self.ex.read(iprot)
21313 
        else:
21314 
          iprot.skip(ftype)
21315 
      else:
21316 
        iprot.skip(ftype)
21317 
      iprot.readFieldEnd()
21318 
    iprot.readStructEnd()
21319 
 
21320 
  def write(self, oprot):
21321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21323 
      return
21324 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
21325 
    if self.success is not None:
21326 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21327 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5411 rajveer 21328 
      for kiter497,viter498 in self.success.items():
21329 
        oprot.writeI64(kiter497)
21330 
        oprot.writeString(viter498)
4600 varun.gupt 21331 
      oprot.writeMapEnd()
21332 
      oprot.writeFieldEnd()
21333 
    if self.ex is not None:
21334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21335 
      self.ex.write(oprot)
21336 
      oprot.writeFieldEnd()
21337 
    oprot.writeFieldStop()
21338 
    oprot.writeStructEnd()
21339 
 
21340 
  def validate(self):
21341 
    return
21342 
 
21343 
 
21344 
  def __repr__(self):
21345 
    L = ['%s=%r' % (key, value)
21346 
      for key, value in self.__dict__.iteritems()]
21347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21348 
 
21349 
  def __eq__(self, other):
21350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21351 
 
21352 
  def __ne__(self, other):
21353 
    return not (self == other)
21354 
 
21355 
class markEBSSettlementUploaded_args:
21356 
  """
21357 
  Attributes:
21358 
   - settlementId
21359 
  """
21360 
 
21361 
  thrift_spec = (
21362 
    None, # 0
21363 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21364 
  )
21365 
 
21366 
  def __init__(self, settlementId=None,):
21367 
    self.settlementId = settlementId
21368 
 
21369 
  def read(self, iprot):
21370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21372 
      return
21373 
    iprot.readStructBegin()
21374 
    while True:
21375 
      (fname, ftype, fid) = iprot.readFieldBegin()
21376 
      if ftype == TType.STOP:
21377 
        break
21378 
      if fid == 1:
21379 
        if ftype == TType.I64:
21380 
          self.settlementId = iprot.readI64();
21381 
        else:
21382 
          iprot.skip(ftype)
21383 
      else:
21384 
        iprot.skip(ftype)
21385 
      iprot.readFieldEnd()
21386 
    iprot.readStructEnd()
21387 
 
21388 
  def write(self, oprot):
21389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21391 
      return
21392 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
21393 
    if self.settlementId is not None:
21394 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21395 
      oprot.writeI64(self.settlementId)
21396 
      oprot.writeFieldEnd()
21397 
    oprot.writeFieldStop()
21398 
    oprot.writeStructEnd()
21399 
 
21400 
  def validate(self):
21401 
    return
21402 
 
21403 
 
21404 
  def __repr__(self):
21405 
    L = ['%s=%r' % (key, value)
21406 
      for key, value in self.__dict__.iteritems()]
21407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21408 
 
21409 
  def __eq__(self, other):
21410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21411 
 
21412 
  def __ne__(self, other):
21413 
    return not (self == other)
21414 
 
21415 
class markEBSSettlementUploaded_result:
21416 
  """
21417 
  Attributes:
21418 
   - ex
21419 
  """
21420 
 
21421 
  thrift_spec = (
21422 
    None, # 0
21423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21424 
  )
21425 
 
21426 
  def __init__(self, ex=None,):
21427 
    self.ex = ex
21428 
 
21429 
  def read(self, iprot):
21430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21432 
      return
21433 
    iprot.readStructBegin()
21434 
    while True:
21435 
      (fname, ftype, fid) = iprot.readFieldBegin()
21436 
      if ftype == TType.STOP:
21437 
        break
21438 
      if fid == 1:
21439 
        if ftype == TType.STRUCT:
21440 
          self.ex = TransactionServiceException()
21441 
          self.ex.read(iprot)
21442 
        else:
21443 
          iprot.skip(ftype)
21444 
      else:
21445 
        iprot.skip(ftype)
21446 
      iprot.readFieldEnd()
21447 
    iprot.readStructEnd()
21448 
 
21449 
  def write(self, oprot):
21450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21452 
      return
21453 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21454 
    if self.ex is not None:
21455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21456 
      self.ex.write(oprot)
21457 
      oprot.writeFieldEnd()
21458 
    oprot.writeFieldStop()
21459 
    oprot.writeStructEnd()
21460 
 
21461 
  def validate(self):
21462 
    return
21463 
 
21464 
 
21465 
  def __repr__(self):
21466 
    L = ['%s=%r' % (key, value)
21467 
      for key, value in self.__dict__.iteritems()]
21468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21469 
 
21470 
  def __eq__(self, other):
21471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21472 
 
21473 
  def __ne__(self, other):
21474 
    return not (self == other)
21475 
 
21476 
class getEBSSettlementDate_args:
21477 
  """
21478 
  Attributes:
21479 
   - settlementId
21480 
  """
21481 
 
21482 
  thrift_spec = (
21483 
    None, # 0
21484 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21485 
  )
21486 
 
21487 
  def __init__(self, settlementId=None,):
21488 
    self.settlementId = settlementId
21489 
 
21490 
  def read(self, iprot):
21491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21493 
      return
21494 
    iprot.readStructBegin()
21495 
    while True:
21496 
      (fname, ftype, fid) = iprot.readFieldBegin()
21497 
      if ftype == TType.STOP:
21498 
        break
21499 
      if fid == 1:
21500 
        if ftype == TType.I64:
21501 
          self.settlementId = iprot.readI64();
21502 
        else:
21503 
          iprot.skip(ftype)
21504 
      else:
21505 
        iprot.skip(ftype)
21506 
      iprot.readFieldEnd()
21507 
    iprot.readStructEnd()
21508 
 
21509 
  def write(self, oprot):
21510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21512 
      return
21513 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21514 
    if self.settlementId is not None:
21515 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21516 
      oprot.writeI64(self.settlementId)
21517 
      oprot.writeFieldEnd()
21518 
    oprot.writeFieldStop()
21519 
    oprot.writeStructEnd()
21520 
 
21521 
  def validate(self):
21522 
    return
21523 
 
21524 
 
21525 
  def __repr__(self):
21526 
    L = ['%s=%r' % (key, value)
21527 
      for key, value in self.__dict__.iteritems()]
21528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21529 
 
21530 
  def __eq__(self, other):
21531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21532 
 
21533 
  def __ne__(self, other):
21534 
    return not (self == other)
21535 
 
21536 
class getEBSSettlementDate_result:
21537 
  """
21538 
  Attributes:
21539 
   - success
21540 
   - ex
21541 
  """
21542 
 
21543 
  thrift_spec = (
21544 
    (0, TType.I64, 'success', None, None, ), # 0
21545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21546 
  )
21547 
 
21548 
  def __init__(self, success=None, ex=None,):
21549 
    self.success = success
21550 
    self.ex = ex
21551 
 
21552 
  def read(self, iprot):
21553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21555 
      return
21556 
    iprot.readStructBegin()
21557 
    while True:
21558 
      (fname, ftype, fid) = iprot.readFieldBegin()
21559 
      if ftype == TType.STOP:
21560 
        break
21561 
      if fid == 0:
21562 
        if ftype == TType.I64:
21563 
          self.success = iprot.readI64();
21564 
        else:
21565 
          iprot.skip(ftype)
21566 
      elif fid == 1:
21567 
        if ftype == TType.STRUCT:
21568 
          self.ex = TransactionServiceException()
21569 
          self.ex.read(iprot)
21570 
        else:
21571 
          iprot.skip(ftype)
21572 
      else:
21573 
        iprot.skip(ftype)
21574 
      iprot.readFieldEnd()
21575 
    iprot.readStructEnd()
21576 
 
21577 
  def write(self, oprot):
21578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21580 
      return
21581 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21582 
    if self.success is not None:
21583 
      oprot.writeFieldBegin('success', TType.I64, 0)
21584 
      oprot.writeI64(self.success)
21585 
      oprot.writeFieldEnd()
21586 
    if self.ex is not None:
21587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21588 
      self.ex.write(oprot)
21589 
      oprot.writeFieldEnd()
21590 
    oprot.writeFieldStop()
21591 
    oprot.writeStructEnd()
21592 
 
21593 
  def validate(self):
21594 
    return
21595 
 
21596 
 
21597 
  def __repr__(self):
21598 
    L = ['%s=%r' % (key, value)
21599 
      for key, value in self.__dict__.iteritems()]
21600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21601 
 
21602 
  def __eq__(self, other):
21603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21604 
 
21605 
  def __ne__(self, other):
21606 
    return not (self == other)
4715 varun.gupt 21607 
 
21608 
class getSettlementsByDate_args:
21609 
  """
21610 
  Attributes:
21611 
   - settlementDateFrom
21612 
   - settlementDateTo
21613 
   - isRefund
21614 
  """
21615 
 
21616 
  thrift_spec = (
21617 
    None, # 0
21618 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21619 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21620 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21621 
  )
21622 
 
21623 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21624 
    self.settlementDateFrom = settlementDateFrom
21625 
    self.settlementDateTo = settlementDateTo
21626 
    self.isRefund = isRefund
21627 
 
21628 
  def read(self, iprot):
21629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21631 
      return
21632 
    iprot.readStructBegin()
21633 
    while True:
21634 
      (fname, ftype, fid) = iprot.readFieldBegin()
21635 
      if ftype == TType.STOP:
21636 
        break
21637 
      if fid == 1:
21638 
        if ftype == TType.I64:
21639 
          self.settlementDateFrom = iprot.readI64();
21640 
        else:
21641 
          iprot.skip(ftype)
21642 
      elif fid == 2:
21643 
        if ftype == TType.I64:
21644 
          self.settlementDateTo = iprot.readI64();
21645 
        else:
21646 
          iprot.skip(ftype)
21647 
      elif fid == 3:
21648 
        if ftype == TType.BOOL:
21649 
          self.isRefund = iprot.readBool();
21650 
        else:
21651 
          iprot.skip(ftype)
21652 
      else:
21653 
        iprot.skip(ftype)
21654 
      iprot.readFieldEnd()
21655 
    iprot.readStructEnd()
21656 
 
21657 
  def write(self, oprot):
21658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21660 
      return
21661 
    oprot.writeStructBegin('getSettlementsByDate_args')
21662 
    if self.settlementDateFrom is not None:
21663 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21664 
      oprot.writeI64(self.settlementDateFrom)
21665 
      oprot.writeFieldEnd()
21666 
    if self.settlementDateTo is not None:
21667 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21668 
      oprot.writeI64(self.settlementDateTo)
21669 
      oprot.writeFieldEnd()
21670 
    if self.isRefund is not None:
21671 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21672 
      oprot.writeBool(self.isRefund)
21673 
      oprot.writeFieldEnd()
21674 
    oprot.writeFieldStop()
21675 
    oprot.writeStructEnd()
21676 
 
21677 
  def validate(self):
21678 
    return
21679 
 
21680 
 
21681 
  def __repr__(self):
21682 
    L = ['%s=%r' % (key, value)
21683 
      for key, value in self.__dict__.iteritems()]
21684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21685 
 
21686 
  def __eq__(self, other):
21687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21688 
 
21689 
  def __ne__(self, other):
21690 
    return not (self == other)
21691 
 
21692 
class getSettlementsByDate_result:
21693 
  """
21694 
  Attributes:
21695 
   - success
21696 
   - ex
21697 
  """
21698 
 
21699 
  thrift_spec = (
21700 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21702 
  )
21703 
 
21704 
  def __init__(self, success=None, ex=None,):
21705 
    self.success = success
21706 
    self.ex = ex
21707 
 
21708 
  def read(self, iprot):
21709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21711 
      return
21712 
    iprot.readStructBegin()
21713 
    while True:
21714 
      (fname, ftype, fid) = iprot.readFieldBegin()
21715 
      if ftype == TType.STOP:
21716 
        break
21717 
      if fid == 0:
21718 
        if ftype == TType.LIST:
21719 
          self.success = []
5411 rajveer 21720 
          (_etype502, _size499) = iprot.readListBegin()
21721 
          for _i503 in xrange(_size499):
21722 
            _elem504 = PaymentSettlement()
21723 
            _elem504.read(iprot)
21724 
            self.success.append(_elem504)
4715 varun.gupt 21725 
          iprot.readListEnd()
21726 
        else:
21727 
          iprot.skip(ftype)
21728 
      elif fid == 1:
21729 
        if ftype == TType.STRUCT:
21730 
          self.ex = TransactionServiceException()
21731 
          self.ex.read(iprot)
21732 
        else:
21733 
          iprot.skip(ftype)
21734 
      else:
21735 
        iprot.skip(ftype)
21736 
      iprot.readFieldEnd()
21737 
    iprot.readStructEnd()
21738 
 
21739 
  def write(self, oprot):
21740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21742 
      return
21743 
    oprot.writeStructBegin('getSettlementsByDate_result')
21744 
    if self.success is not None:
21745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 21747 
      for iter505 in self.success:
21748 
        iter505.write(oprot)
4715 varun.gupt 21749 
      oprot.writeListEnd()
21750 
      oprot.writeFieldEnd()
21751 
    if self.ex is not None:
21752 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21753 
      self.ex.write(oprot)
21754 
      oprot.writeFieldEnd()
21755 
    oprot.writeFieldStop()
21756 
    oprot.writeStructEnd()
21757 
 
21758 
  def validate(self):
21759 
    return
21760 
 
21761 
 
21762 
  def __repr__(self):
21763 
    L = ['%s=%r' % (key, value)
21764 
      for key, value in self.__dict__.iteritems()]
21765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21766 
 
21767 
  def __eq__(self, other):
21768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21769 
 
21770 
  def __ne__(self, other):
21771 
    return not (self == other)
21772 
 
21773 
class getReshippedOrderIds_args:
21774 
  """
21775 
  Attributes:
21776 
   - orderIds
21777 
  """
21778 
 
21779 
  thrift_spec = (
21780 
    None, # 0
21781 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21782 
  )
21783 
 
21784 
  def __init__(self, orderIds=None,):
21785 
    self.orderIds = orderIds
21786 
 
21787 
  def read(self, iprot):
21788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21790 
      return
21791 
    iprot.readStructBegin()
21792 
    while True:
21793 
      (fname, ftype, fid) = iprot.readFieldBegin()
21794 
      if ftype == TType.STOP:
21795 
        break
21796 
      if fid == 1:
21797 
        if ftype == TType.LIST:
21798 
          self.orderIds = []
5411 rajveer 21799 
          (_etype509, _size506) = iprot.readListBegin()
21800 
          for _i510 in xrange(_size506):
21801 
            _elem511 = iprot.readI64();
21802 
            self.orderIds.append(_elem511)
4715 varun.gupt 21803 
          iprot.readListEnd()
21804 
        else:
21805 
          iprot.skip(ftype)
21806 
      else:
21807 
        iprot.skip(ftype)
21808 
      iprot.readFieldEnd()
21809 
    iprot.readStructEnd()
21810 
 
21811 
  def write(self, oprot):
21812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21814 
      return
21815 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21816 
    if self.orderIds is not None:
21817 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21818 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 21819 
      for iter512 in self.orderIds:
21820 
        oprot.writeI64(iter512)
4715 varun.gupt 21821 
      oprot.writeListEnd()
21822 
      oprot.writeFieldEnd()
21823 
    oprot.writeFieldStop()
21824 
    oprot.writeStructEnd()
21825 
 
21826 
  def validate(self):
21827 
    return
21828 
 
21829 
 
21830 
  def __repr__(self):
21831 
    L = ['%s=%r' % (key, value)
21832 
      for key, value in self.__dict__.iteritems()]
21833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21834 
 
21835 
  def __eq__(self, other):
21836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21837 
 
21838 
  def __ne__(self, other):
21839 
    return not (self == other)
21840 
 
21841 
class getReshippedOrderIds_result:
21842 
  """
21843 
  Attributes:
21844 
   - success
21845 
   - ex
21846 
  """
21847 
 
21848 
  thrift_spec = (
21849 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21851 
  )
21852 
 
21853 
  def __init__(self, success=None, ex=None,):
21854 
    self.success = success
21855 
    self.ex = ex
21856 
 
21857 
  def read(self, iprot):
21858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21860 
      return
21861 
    iprot.readStructBegin()
21862 
    while True:
21863 
      (fname, ftype, fid) = iprot.readFieldBegin()
21864 
      if ftype == TType.STOP:
21865 
        break
21866 
      if fid == 0:
21867 
        if ftype == TType.LIST:
21868 
          self.success = []
5411 rajveer 21869 
          (_etype516, _size513) = iprot.readListBegin()
21870 
          for _i517 in xrange(_size513):
21871 
            _elem518 = iprot.readI64();
21872 
            self.success.append(_elem518)
4715 varun.gupt 21873 
          iprot.readListEnd()
21874 
        else:
21875 
          iprot.skip(ftype)
21876 
      elif fid == 1:
21877 
        if ftype == TType.STRUCT:
21878 
          self.ex = TransactionServiceException()
21879 
          self.ex.read(iprot)
21880 
        else:
21881 
          iprot.skip(ftype)
21882 
      else:
21883 
        iprot.skip(ftype)
21884 
      iprot.readFieldEnd()
21885 
    iprot.readStructEnd()
21886 
 
21887 
  def write(self, oprot):
21888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21890 
      return
21891 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21892 
    if self.success is not None:
21893 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21894 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 21895 
      for iter519 in self.success:
21896 
        oprot.writeI64(iter519)
4715 varun.gupt 21897 
      oprot.writeListEnd()
21898 
      oprot.writeFieldEnd()
21899 
    if self.ex is not None:
21900 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21901 
      self.ex.write(oprot)
21902 
      oprot.writeFieldEnd()
21903 
    oprot.writeFieldStop()
21904 
    oprot.writeStructEnd()
21905 
 
21906 
  def validate(self):
21907 
    return
21908 
 
21909 
 
21910 
  def __repr__(self):
21911 
    L = ['%s=%r' % (key, value)
21912 
      for key, value in self.__dict__.iteritems()]
21913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21914 
 
21915 
  def __eq__(self, other):
21916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21917 
 
21918 
  def __ne__(self, other):
21919 
    return not (self == other)
4757 mandeep.dh 21920 
 
4875 varun.gupt 21921 
class getOrdersWhereVendorNotPaid_args:
21922 
  """
21923 
  Attributes:
21924 
   - vendorId
21925 
  """
21926 
 
21927 
  thrift_spec = (
21928 
    None, # 0
21929 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21930 
  )
21931 
 
21932 
  def __init__(self, vendorId=None,):
21933 
    self.vendorId = vendorId
21934 
 
21935 
  def read(self, iprot):
21936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21938 
      return
21939 
    iprot.readStructBegin()
21940 
    while True:
21941 
      (fname, ftype, fid) = iprot.readFieldBegin()
21942 
      if ftype == TType.STOP:
21943 
        break
21944 
      if fid == 1:
21945 
        if ftype == TType.I64:
21946 
          self.vendorId = iprot.readI64();
21947 
        else:
21948 
          iprot.skip(ftype)
21949 
      else:
21950 
        iprot.skip(ftype)
21951 
      iprot.readFieldEnd()
21952 
    iprot.readStructEnd()
21953 
 
21954 
  def write(self, oprot):
21955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21957 
      return
21958 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21959 
    if self.vendorId is not None:
21960 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21961 
      oprot.writeI64(self.vendorId)
21962 
      oprot.writeFieldEnd()
21963 
    oprot.writeFieldStop()
21964 
    oprot.writeStructEnd()
21965 
 
21966 
  def validate(self):
21967 
    return
21968 
 
21969 
 
21970 
  def __repr__(self):
21971 
    L = ['%s=%r' % (key, value)
21972 
      for key, value in self.__dict__.iteritems()]
21973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21974 
 
21975 
  def __eq__(self, other):
21976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21977 
 
21978 
  def __ne__(self, other):
21979 
    return not (self == other)
21980 
 
21981 
class getOrdersWhereVendorNotPaid_result:
21982 
  """
21983 
  Attributes:
21984 
   - success
21985 
   - ex
21986 
  """
21987 
 
21988 
  thrift_spec = (
21989 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21991 
  )
21992 
 
21993 
  def __init__(self, success=None, ex=None,):
21994 
    self.success = success
21995 
    self.ex = ex
21996 
 
21997 
  def read(self, iprot):
21998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22000 
      return
22001 
    iprot.readStructBegin()
22002 
    while True:
22003 
      (fname, ftype, fid) = iprot.readFieldBegin()
22004 
      if ftype == TType.STOP:
22005 
        break
22006 
      if fid == 0:
22007 
        if ftype == TType.LIST:
22008 
          self.success = []
5411 rajveer 22009 
          (_etype523, _size520) = iprot.readListBegin()
22010 
          for _i524 in xrange(_size520):
22011 
            _elem525 = Order()
22012 
            _elem525.read(iprot)
22013 
            self.success.append(_elem525)
4875 varun.gupt 22014 
          iprot.readListEnd()
22015 
        else:
22016 
          iprot.skip(ftype)
22017 
      elif fid == 1:
22018 
        if ftype == TType.STRUCT:
22019 
          self.ex = TransactionServiceException()
22020 
          self.ex.read(iprot)
22021 
        else:
22022 
          iprot.skip(ftype)
22023 
      else:
22024 
        iprot.skip(ftype)
22025 
      iprot.readFieldEnd()
22026 
    iprot.readStructEnd()
22027 
 
22028 
  def write(self, oprot):
22029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22031 
      return
22032 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
22033 
    if self.success is not None:
22034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 22036 
      for iter526 in self.success:
22037 
        iter526.write(oprot)
4875 varun.gupt 22038 
      oprot.writeListEnd()
22039 
      oprot.writeFieldEnd()
22040 
    if self.ex is not None:
22041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22042 
      self.ex.write(oprot)
22043 
      oprot.writeFieldEnd()
22044 
    oprot.writeFieldStop()
22045 
    oprot.writeStructEnd()
22046 
 
22047 
  def validate(self):
22048 
    return
22049 
 
22050 
 
22051 
  def __repr__(self):
22052 
    L = ['%s=%r' % (key, value)
22053 
      for key, value in self.__dict__.iteritems()]
22054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22055 
 
22056 
  def __eq__(self, other):
22057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22058 
 
22059 
  def __ne__(self, other):
22060 
    return not (self == other)
5031 varun.gupt 22061 
 
22062 
class getStatusDistributionOfOrders_args:
22063 
  """
22064 
  Attributes:
22065 
   - startDate
22066 
   - endDate
22067 
  """
22068 
 
22069 
  thrift_spec = (
22070 
    None, # 0
22071 
    (1, TType.I64, 'startDate', None, None, ), # 1
22072 
    (2, TType.I64, 'endDate', None, None, ), # 2
22073 
  )
22074 
 
22075 
  def __init__(self, startDate=None, endDate=None,):
22076 
    self.startDate = startDate
22077 
    self.endDate = endDate
22078 
 
22079 
  def read(self, iprot):
22080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22082 
      return
22083 
    iprot.readStructBegin()
22084 
    while True:
22085 
      (fname, ftype, fid) = iprot.readFieldBegin()
22086 
      if ftype == TType.STOP:
22087 
        break
22088 
      if fid == 1:
22089 
        if ftype == TType.I64:
22090 
          self.startDate = iprot.readI64();
22091 
        else:
22092 
          iprot.skip(ftype)
22093 
      elif fid == 2:
22094 
        if ftype == TType.I64:
22095 
          self.endDate = iprot.readI64();
22096 
        else:
22097 
          iprot.skip(ftype)
22098 
      else:
22099 
        iprot.skip(ftype)
22100 
      iprot.readFieldEnd()
22101 
    iprot.readStructEnd()
22102 
 
22103 
  def write(self, oprot):
22104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22106 
      return
22107 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22108 
    if self.startDate is not None:
22109 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22110 
      oprot.writeI64(self.startDate)
22111 
      oprot.writeFieldEnd()
22112 
    if self.endDate is not None:
22113 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22114 
      oprot.writeI64(self.endDate)
22115 
      oprot.writeFieldEnd()
22116 
    oprot.writeFieldStop()
22117 
    oprot.writeStructEnd()
22118 
 
22119 
  def validate(self):
22120 
    return
22121 
 
22122 
 
22123 
  def __repr__(self):
22124 
    L = ['%s=%r' % (key, value)
22125 
      for key, value in self.__dict__.iteritems()]
22126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22127 
 
22128 
  def __eq__(self, other):
22129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22130 
 
22131 
  def __ne__(self, other):
22132 
    return not (self == other)
22133 
 
22134 
class getStatusDistributionOfOrders_result:
22135 
  """
22136 
  Attributes:
22137 
   - success
22138 
   - ex
22139 
  """
22140 
 
22141 
  thrift_spec = (
22142 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22144 
  )
22145 
 
22146 
  def __init__(self, success=None, ex=None,):
22147 
    self.success = success
22148 
    self.ex = ex
22149 
 
22150 
  def read(self, iprot):
22151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22153 
      return
22154 
    iprot.readStructBegin()
22155 
    while True:
22156 
      (fname, ftype, fid) = iprot.readFieldBegin()
22157 
      if ftype == TType.STOP:
22158 
        break
22159 
      if fid == 0:
22160 
        if ftype == TType.MAP:
22161 
          self.success = {}
5411 rajveer 22162 
          (_ktype528, _vtype529, _size527 ) = iprot.readMapBegin()
22163 
          for _i531 in xrange(_size527):
22164 
            _key532 = iprot.readI64();
22165 
            _val533 = iprot.readI64();
22166 
            self.success[_key532] = _val533
5031 varun.gupt 22167 
          iprot.readMapEnd()
22168 
        else:
22169 
          iprot.skip(ftype)
22170 
      elif fid == 1:
22171 
        if ftype == TType.STRUCT:
22172 
          self.ex = TransactionServiceException()
22173 
          self.ex.read(iprot)
22174 
        else:
22175 
          iprot.skip(ftype)
22176 
      else:
22177 
        iprot.skip(ftype)
22178 
      iprot.readFieldEnd()
22179 
    iprot.readStructEnd()
22180 
 
22181 
  def write(self, oprot):
22182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22184 
      return
22185 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22186 
    if self.success is not None:
22187 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22188 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5411 rajveer 22189 
      for kiter534,viter535 in self.success.items():
22190 
        oprot.writeI64(kiter534)
22191 
        oprot.writeI64(viter535)
5031 varun.gupt 22192 
      oprot.writeMapEnd()
22193 
      oprot.writeFieldEnd()
22194 
    if self.ex is not None:
22195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22196 
      self.ex.write(oprot)
22197 
      oprot.writeFieldEnd()
22198 
    oprot.writeFieldStop()
22199 
    oprot.writeStructEnd()
22200 
 
22201 
  def validate(self):
22202 
    return
22203 
 
22204 
 
22205 
  def __repr__(self):
22206 
    L = ['%s=%r' % (key, value)
22207 
      for key, value in self.__dict__.iteritems()]
22208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22209 
 
22210 
  def __eq__(self, other):
22211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22212 
 
22213 
  def __ne__(self, other):
22214 
    return not (self == other)
5067 varun.gupt 22215 
 
22216 
class getOrderIdsForStatus_args:
22217 
  """
22218 
  Attributes:
22219 
   - status
22220 
   - startDatetime
22221 
   - endDatetime
22222 
  """
22223 
 
22224 
  thrift_spec = (
22225 
    None, # 0
22226 
    (1, TType.I64, 'status', None, None, ), # 1
22227 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22228 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22229 
  )
22230 
 
22231 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22232 
    self.status = status
22233 
    self.startDatetime = startDatetime
22234 
    self.endDatetime = endDatetime
22235 
 
22236 
  def read(self, iprot):
22237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22239 
      return
22240 
    iprot.readStructBegin()
22241 
    while True:
22242 
      (fname, ftype, fid) = iprot.readFieldBegin()
22243 
      if ftype == TType.STOP:
22244 
        break
22245 
      if fid == 1:
22246 
        if ftype == TType.I64:
22247 
          self.status = iprot.readI64();
22248 
        else:
22249 
          iprot.skip(ftype)
22250 
      elif fid == 2:
22251 
        if ftype == TType.I64:
22252 
          self.startDatetime = iprot.readI64();
22253 
        else:
22254 
          iprot.skip(ftype)
22255 
      elif fid == 3:
22256 
        if ftype == TType.I64:
22257 
          self.endDatetime = iprot.readI64();
22258 
        else:
22259 
          iprot.skip(ftype)
22260 
      else:
22261 
        iprot.skip(ftype)
22262 
      iprot.readFieldEnd()
22263 
    iprot.readStructEnd()
22264 
 
22265 
  def write(self, oprot):
22266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22268 
      return
22269 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22270 
    if self.status is not None:
22271 
      oprot.writeFieldBegin('status', TType.I64, 1)
22272 
      oprot.writeI64(self.status)
22273 
      oprot.writeFieldEnd()
22274 
    if self.startDatetime is not None:
22275 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22276 
      oprot.writeI64(self.startDatetime)
22277 
      oprot.writeFieldEnd()
22278 
    if self.endDatetime is not None:
22279 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22280 
      oprot.writeI64(self.endDatetime)
22281 
      oprot.writeFieldEnd()
22282 
    oprot.writeFieldStop()
22283 
    oprot.writeStructEnd()
22284 
 
22285 
  def validate(self):
22286 
    return
22287 
 
22288 
 
22289 
  def __repr__(self):
22290 
    L = ['%s=%r' % (key, value)
22291 
      for key, value in self.__dict__.iteritems()]
22292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22293 
 
22294 
  def __eq__(self, other):
22295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22296 
 
22297 
  def __ne__(self, other):
22298 
    return not (self == other)
22299 
 
22300 
class getOrderIdsForStatus_result:
22301 
  """
22302 
  Attributes:
22303 
   - success
22304 
   - ex
22305 
  """
22306 
 
22307 
  thrift_spec = (
22308 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22310 
  )
22311 
 
22312 
  def __init__(self, success=None, ex=None,):
22313 
    self.success = success
22314 
    self.ex = ex
22315 
 
22316 
  def read(self, iprot):
22317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22319 
      return
22320 
    iprot.readStructBegin()
22321 
    while True:
22322 
      (fname, ftype, fid) = iprot.readFieldBegin()
22323 
      if ftype == TType.STOP:
22324 
        break
22325 
      if fid == 0:
22326 
        if ftype == TType.LIST:
22327 
          self.success = []
5411 rajveer 22328 
          (_etype539, _size536) = iprot.readListBegin()
22329 
          for _i540 in xrange(_size536):
22330 
            _elem541 = iprot.readI64();
22331 
            self.success.append(_elem541)
5067 varun.gupt 22332 
          iprot.readListEnd()
22333 
        else:
22334 
          iprot.skip(ftype)
22335 
      elif fid == 1:
22336 
        if ftype == TType.STRUCT:
22337 
          self.ex = TransactionServiceException()
22338 
          self.ex.read(iprot)
22339 
        else:
22340 
          iprot.skip(ftype)
22341 
      else:
22342 
        iprot.skip(ftype)
22343 
      iprot.readFieldEnd()
22344 
    iprot.readStructEnd()
22345 
 
22346 
  def write(self, oprot):
22347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22349 
      return
22350 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22351 
    if self.success is not None:
22352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22353 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 22354 
      for iter542 in self.success:
22355 
        oprot.writeI64(iter542)
5067 varun.gupt 22356 
      oprot.writeListEnd()
22357 
      oprot.writeFieldEnd()
22358 
    if self.ex is not None:
22359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22360 
      self.ex.write(oprot)
22361 
      oprot.writeFieldEnd()
22362 
    oprot.writeFieldStop()
22363 
    oprot.writeStructEnd()
22364 
 
22365 
  def validate(self):
22366 
    return
22367 
 
22368 
 
22369 
  def __repr__(self):
22370 
    L = ['%s=%r' % (key, value)
22371 
      for key, value in self.__dict__.iteritems()]
22372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22373 
 
22374 
  def __eq__(self, other):
22375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22376 
 
22377 
  def __ne__(self, other):
22378 
    return not (self == other)
5099 varun.gupt 22379 
 
5348 anupam.sin 22380 
class updateCODAgent_args:
22381 
  """
22382 
  Attributes:
22383 
   - agent
22384 
   - orderId
22385 
  """
22386 
 
22387 
  thrift_spec = (
22388 
    None, # 0
22389 
    (1, TType.STRING, 'agent', None, None, ), # 1
22390 
    (2, TType.I64, 'orderId', None, None, ), # 2
22391 
  )
22392 
 
22393 
  def __init__(self, agent=None, orderId=None,):
22394 
    self.agent = agent
22395 
    self.orderId = orderId
22396 
 
22397 
  def read(self, iprot):
22398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22400 
      return
22401 
    iprot.readStructBegin()
22402 
    while True:
22403 
      (fname, ftype, fid) = iprot.readFieldBegin()
22404 
      if ftype == TType.STOP:
22405 
        break
22406 
      if fid == 1:
22407 
        if ftype == TType.STRING:
22408 
          self.agent = iprot.readString();
22409 
        else:
22410 
          iprot.skip(ftype)
22411 
      elif fid == 2:
22412 
        if ftype == TType.I64:
22413 
          self.orderId = iprot.readI64();
22414 
        else:
22415 
          iprot.skip(ftype)
22416 
      else:
22417 
        iprot.skip(ftype)
22418 
      iprot.readFieldEnd()
22419 
    iprot.readStructEnd()
22420 
 
22421 
  def write(self, oprot):
22422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22424 
      return
22425 
    oprot.writeStructBegin('updateCODAgent_args')
22426 
    if self.agent is not None:
22427 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22428 
      oprot.writeString(self.agent)
22429 
      oprot.writeFieldEnd()
22430 
    if self.orderId is not None:
22431 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22432 
      oprot.writeI64(self.orderId)
22433 
      oprot.writeFieldEnd()
22434 
    oprot.writeFieldStop()
22435 
    oprot.writeStructEnd()
22436 
 
22437 
  def validate(self):
22438 
    return
22439 
 
22440 
 
22441 
  def __repr__(self):
22442 
    L = ['%s=%r' % (key, value)
22443 
      for key, value in self.__dict__.iteritems()]
22444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22445 
 
22446 
  def __eq__(self, other):
22447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22448 
 
22449 
  def __ne__(self, other):
22450 
    return not (self == other)
22451 
 
22452 
class updateCODAgent_result:
22453 
  """
22454 
  Attributes:
22455 
   - ex
22456 
  """
22457 
 
22458 
  thrift_spec = (
22459 
    None, # 0
22460 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22461 
  )
22462 
 
22463 
  def __init__(self, ex=None,):
22464 
    self.ex = ex
22465 
 
22466 
  def read(self, iprot):
22467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22469 
      return
22470 
    iprot.readStructBegin()
22471 
    while True:
22472 
      (fname, ftype, fid) = iprot.readFieldBegin()
22473 
      if ftype == TType.STOP:
22474 
        break
22475 
      if fid == 1:
22476 
        if ftype == TType.STRUCT:
22477 
          self.ex = TransactionServiceException()
22478 
          self.ex.read(iprot)
22479 
        else:
22480 
          iprot.skip(ftype)
22481 
      else:
22482 
        iprot.skip(ftype)
22483 
      iprot.readFieldEnd()
22484 
    iprot.readStructEnd()
22485 
 
22486 
  def write(self, oprot):
22487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22489 
      return
22490 
    oprot.writeStructBegin('updateCODAgent_result')
22491 
    if self.ex is not None:
22492 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22493 
      self.ex.write(oprot)
22494 
      oprot.writeFieldEnd()
22495 
    oprot.writeFieldStop()
22496 
    oprot.writeStructEnd()
22497 
 
22498 
  def validate(self):
22499 
    return
22500 
 
22501 
 
22502 
  def __repr__(self):
22503 
    L = ['%s=%r' % (key, value)
22504 
      for key, value in self.__dict__.iteritems()]
22505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22506 
 
22507 
  def __eq__(self, other):
22508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22509 
 
22510 
  def __ne__(self, other):
22511 
    return not (self == other)
22512 
 
5099 varun.gupt 22513 
class updateOrderAsPaidToVendor_args:
22514 
  """
22515 
  Attributes:
22516 
   - orderId
22517 
  """
22518 
 
22519 
  thrift_spec = (
22520 
    None, # 0
22521 
    (1, TType.I64, 'orderId', None, None, ), # 1
22522 
  )
22523 
 
22524 
  def __init__(self, orderId=None,):
22525 
    self.orderId = orderId
22526 
 
22527 
  def read(self, iprot):
22528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22530 
      return
22531 
    iprot.readStructBegin()
22532 
    while True:
22533 
      (fname, ftype, fid) = iprot.readFieldBegin()
22534 
      if ftype == TType.STOP:
22535 
        break
22536 
      if fid == 1:
22537 
        if ftype == TType.I64:
22538 
          self.orderId = iprot.readI64();
22539 
        else:
22540 
          iprot.skip(ftype)
22541 
      else:
22542 
        iprot.skip(ftype)
22543 
      iprot.readFieldEnd()
22544 
    iprot.readStructEnd()
22545 
 
22546 
  def write(self, oprot):
22547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22549 
      return
22550 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22551 
    if self.orderId is not None:
22552 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22553 
      oprot.writeI64(self.orderId)
22554 
      oprot.writeFieldEnd()
22555 
    oprot.writeFieldStop()
22556 
    oprot.writeStructEnd()
22557 
 
22558 
  def validate(self):
22559 
    return
22560 
 
22561 
 
22562 
  def __repr__(self):
22563 
    L = ['%s=%r' % (key, value)
22564 
      for key, value in self.__dict__.iteritems()]
22565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22566 
 
22567 
  def __eq__(self, other):
22568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22569 
 
22570 
  def __ne__(self, other):
22571 
    return not (self == other)
22572 
 
22573 
class updateOrderAsPaidToVendor_result:
22574 
  """
22575 
  Attributes:
22576 
   - ex
22577 
  """
22578 
 
22579 
  thrift_spec = (
22580 
    None, # 0
22581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22582 
  )
22583 
 
22584 
  def __init__(self, ex=None,):
22585 
    self.ex = ex
22586 
 
22587 
  def read(self, iprot):
22588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22590 
      return
22591 
    iprot.readStructBegin()
22592 
    while True:
22593 
      (fname, ftype, fid) = iprot.readFieldBegin()
22594 
      if ftype == TType.STOP:
22595 
        break
22596 
      if fid == 1:
22597 
        if ftype == TType.STRUCT:
22598 
          self.ex = TransactionServiceException()
22599 
          self.ex.read(iprot)
22600 
        else:
22601 
          iprot.skip(ftype)
22602 
      else:
22603 
        iprot.skip(ftype)
22604 
      iprot.readFieldEnd()
22605 
    iprot.readStructEnd()
22606 
 
22607 
  def write(self, oprot):
22608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22610 
      return
22611 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22612 
    if self.ex is not None:
22613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22614 
      self.ex.write(oprot)
22615 
      oprot.writeFieldEnd()
22616 
    oprot.writeFieldStop()
22617 
    oprot.writeStructEnd()
22618 
 
22619 
  def validate(self):
22620 
    return
22621 
 
22622 
 
22623 
  def __repr__(self):
22624 
    L = ['%s=%r' % (key, value)
22625 
      for key, value in self.__dict__.iteritems()]
22626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22627 
 
22628 
  def __eq__(self, other):
22629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22630 
 
22631 
  def __ne__(self, other):
22632 
    return not (self == other)
5208 varun.gupt 22633 
 
5386 phani.kuma 22634 
class updateOrderOnlyAsPaidToVendor_args:
22635 
  """
22636 
  Attributes:
22637 
   - orderId
22638 
  """
22639 
 
22640 
  thrift_spec = (
22641 
    None, # 0
22642 
    (1, TType.I64, 'orderId', None, None, ), # 1
22643 
  )
22644 
 
22645 
  def __init__(self, orderId=None,):
22646 
    self.orderId = orderId
22647 
 
22648 
  def read(self, iprot):
22649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22651 
      return
22652 
    iprot.readStructBegin()
22653 
    while True:
22654 
      (fname, ftype, fid) = iprot.readFieldBegin()
22655 
      if ftype == TType.STOP:
22656 
        break
22657 
      if fid == 1:
22658 
        if ftype == TType.I64:
22659 
          self.orderId = iprot.readI64();
22660 
        else:
22661 
          iprot.skip(ftype)
22662 
      else:
22663 
        iprot.skip(ftype)
22664 
      iprot.readFieldEnd()
22665 
    iprot.readStructEnd()
22666 
 
22667 
  def write(self, oprot):
22668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22670 
      return
22671 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
22672 
    if self.orderId is not None:
22673 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22674 
      oprot.writeI64(self.orderId)
22675 
      oprot.writeFieldEnd()
22676 
    oprot.writeFieldStop()
22677 
    oprot.writeStructEnd()
22678 
 
22679 
  def validate(self):
22680 
    return
22681 
 
22682 
 
22683 
  def __repr__(self):
22684 
    L = ['%s=%r' % (key, value)
22685 
      for key, value in self.__dict__.iteritems()]
22686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22687 
 
22688 
  def __eq__(self, other):
22689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22690 
 
22691 
  def __ne__(self, other):
22692 
    return not (self == other)
22693 
 
22694 
class updateOrderOnlyAsPaidToVendor_result:
22695 
  """
22696 
  Attributes:
22697 
   - ex
22698 
  """
22699 
 
22700 
  thrift_spec = (
22701 
    None, # 0
22702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22703 
  )
22704 
 
22705 
  def __init__(self, ex=None,):
22706 
    self.ex = ex
22707 
 
22708 
  def read(self, iprot):
22709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22711 
      return
22712 
    iprot.readStructBegin()
22713 
    while True:
22714 
      (fname, ftype, fid) = iprot.readFieldBegin()
22715 
      if ftype == TType.STOP:
22716 
        break
22717 
      if fid == 1:
22718 
        if ftype == TType.STRUCT:
22719 
          self.ex = TransactionServiceException()
22720 
          self.ex.read(iprot)
22721 
        else:
22722 
          iprot.skip(ftype)
22723 
      else:
22724 
        iprot.skip(ftype)
22725 
      iprot.readFieldEnd()
22726 
    iprot.readStructEnd()
22727 
 
22728 
  def write(self, oprot):
22729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22731 
      return
22732 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
22733 
    if self.ex is not None:
22734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22735 
      self.ex.write(oprot)
22736 
      oprot.writeFieldEnd()
22737 
    oprot.writeFieldStop()
22738 
    oprot.writeStructEnd()
22739 
 
22740 
  def validate(self):
22741 
    return
22742 
 
22743 
 
22744 
  def __repr__(self):
22745 
    L = ['%s=%r' % (key, value)
22746 
      for key, value in self.__dict__.iteritems()]
22747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22748 
 
22749 
  def __eq__(self, other):
22750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22751 
 
22752 
  def __ne__(self, other):
22753 
    return not (self == other)
22754 
 
5208 varun.gupt 22755 
class getRefundedOrdersMarkedPaid_args:
22756 
 
22757 
  thrift_spec = (
22758 
  )
22759 
 
22760 
  def read(self, iprot):
22761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22763 
      return
22764 
    iprot.readStructBegin()
22765 
    while True:
22766 
      (fname, ftype, fid) = iprot.readFieldBegin()
22767 
      if ftype == TType.STOP:
22768 
        break
22769 
      else:
22770 
        iprot.skip(ftype)
22771 
      iprot.readFieldEnd()
22772 
    iprot.readStructEnd()
22773 
 
22774 
  def write(self, oprot):
22775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22777 
      return
22778 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22779 
    oprot.writeFieldStop()
22780 
    oprot.writeStructEnd()
22781 
 
22782 
  def validate(self):
22783 
    return
22784 
 
22785 
 
22786 
  def __repr__(self):
22787 
    L = ['%s=%r' % (key, value)
22788 
      for key, value in self.__dict__.iteritems()]
22789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22790 
 
22791 
  def __eq__(self, other):
22792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22793 
 
22794 
  def __ne__(self, other):
22795 
    return not (self == other)
22796 
 
22797 
class getRefundedOrdersMarkedPaid_result:
22798 
  """
22799 
  Attributes:
22800 
   - success
22801 
   - ex
22802 
  """
22803 
 
22804 
  thrift_spec = (
22805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22807 
  )
22808 
 
22809 
  def __init__(self, success=None, ex=None,):
22810 
    self.success = success
22811 
    self.ex = ex
22812 
 
22813 
  def read(self, iprot):
22814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22816 
      return
22817 
    iprot.readStructBegin()
22818 
    while True:
22819 
      (fname, ftype, fid) = iprot.readFieldBegin()
22820 
      if ftype == TType.STOP:
22821 
        break
22822 
      if fid == 0:
22823 
        if ftype == TType.LIST:
22824 
          self.success = []
5411 rajveer 22825 
          (_etype546, _size543) = iprot.readListBegin()
22826 
          for _i547 in xrange(_size543):
22827 
            _elem548 = Order()
22828 
            _elem548.read(iprot)
22829 
            self.success.append(_elem548)
5208 varun.gupt 22830 
          iprot.readListEnd()
22831 
        else:
22832 
          iprot.skip(ftype)
22833 
      elif fid == 1:
22834 
        if ftype == TType.STRUCT:
22835 
          self.ex = TransactionServiceException()
22836 
          self.ex.read(iprot)
22837 
        else:
22838 
          iprot.skip(ftype)
22839 
      else:
22840 
        iprot.skip(ftype)
22841 
      iprot.readFieldEnd()
22842 
    iprot.readStructEnd()
22843 
 
22844 
  def write(self, oprot):
22845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22847 
      return
22848 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22849 
    if self.success is not None:
22850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 22852 
      for iter549 in self.success:
22853 
        iter549.write(oprot)
5208 varun.gupt 22854 
      oprot.writeListEnd()
22855 
      oprot.writeFieldEnd()
22856 
    if self.ex is not None:
22857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22858 
      self.ex.write(oprot)
22859 
      oprot.writeFieldEnd()
22860 
    oprot.writeFieldStop()
22861 
    oprot.writeStructEnd()
22862 
 
22863 
  def validate(self):
22864 
    return
22865 
 
22866 
 
22867 
  def __repr__(self):
22868 
    L = ['%s=%r' % (key, value)
22869 
      for key, value in self.__dict__.iteritems()]
22870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22871 
 
22872 
  def __eq__(self, other):
22873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22874 
 
22875 
  def __ne__(self, other):
22876 
    return not (self == other)