Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
281 
  def getValidOrders(self, limit):
282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
288 
    """
289 
    pass
290 
 
1220 chandransh 291 
  def batchOrders(self, warehouseId):
292 
    """
293 
    Create a batch of all the pending orders for the given warehouse.
294 
    The returned list is orderd by created_timestamp.
295 
    If there are no pending orders, an empty list is returned.
3431 rajveer 296 
 
1220 chandransh 297 
    Parameters:
298 
     - warehouseId
299 
    """
300 
    pass
301 
 
1208 chandransh 302 
  def markOrderAsOutOfStock(self, orderId):
303 
    """
304 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 305 
 
1208 chandransh 306 
    Parameters:
307 
     - orderId
308 
    """
309 
    pass
310 
 
3064 chandransh 311 
  def verifyOrder(self, orderId):
759 chandransh 312 
    """
3064 chandransh 313 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
314 
    timestamp. It is intended to be used for COD orders but can be harmlessly
315 
    used for all other orders as well.
316 
    Throws an exception if no such order exists.
3431 rajveer 317 
 
759 chandransh 318 
    Parameters:
3064 chandransh 319 
     - orderId
320 
    """
321 
    pass
322 
 
323 
  def acceptOrder(self, orderId):
324 
    """
325 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
326 
    given order is not a COD order, it also captures the payment if the same has
327 
    not been captured.
328 
    Throws an exception if no such order exists.
3431 rajveer 329 
 
3064 chandransh 330 
    Parameters:
331 
     - orderId
332 
    """
333 
    pass
334 
 
5110 mandeep.dh 335 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 336 
    """
337 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 338 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 339 
    the IMEI no. if a -1 is supplied.
340 
    Also, it generates an invoice number for the order, marks the order as
341 
    BILLED and sets the billing timestamp.
342 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 343 
 
3064 chandransh 344 
    Parameters:
345 
     - orderId
4283 anupam.sin 346 
     - invoice_number
4658 mandeep.dh 347 
     - serialNumber
3064 chandransh 348 
     - itemNumber
4283 anupam.sin 349 
     - billed_by
350 
     - jacketNumber
3064 chandransh 351 
     - billingType
5110 mandeep.dh 352 
     - fulfilmentWarehouseId
4763 rajveer 353 
     - authorize
3064 chandransh 354 
    """
355 
    pass
356 
 
4763 rajveer 357 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 358 
    """
359 
    Add the invoice number to the order.
360 
 
361 
    Parameters:
362 
     - orderId
363 
     - invoiceNumber
4763 rajveer 364 
     - color
4579 rajveer 365 
    """
366 
    pass
367 
 
4910 phani.kuma 368 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 369 
    """
370 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 371 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 372 
 
373 
    Parameters:
374 
     - warehouseId
375 
     - providerId
376 
     - cod
4910 phani.kuma 377 
     - orderIds
4410 rajveer 378 
    """
379 
    pass
380 
 
4910 phani.kuma 381 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 382 
    """
4910 phani.kuma 383 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
384 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 385 
 
3064 chandransh 386 
    Parameters:
759 chandransh 387 
     - providerId
4910 phani.kuma 388 
     - pickupDetails
759 chandransh 389 
    """
390 
    pass
391 
 
4910 phani.kuma 392 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 393 
    """
394 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 395 
 
1113 chandransh 396 
    Parameters:
397 
     - providerId
398 
    """
399 
    pass
400 
 
1132 chandransh 401 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
402 
    """
403 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
404 
    the name of the receiver.
405 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 406 
 
1132 chandransh 407 
    Parameters:
408 
     - providerId
409 
     - deliveredOrders
410 
    """
411 
    pass
412 
 
4910 phani.kuma 413 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 414 
    """
4910 phani.kuma 415 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 416 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 417 
 
1135 chandransh 418 
    Parameters:
419 
     - providerId
420 
     - returnedOrders
421 
    """
422 
    pass
423 
 
4910 phani.kuma 424 
  def getRTOrders(self, providerId):
425 
    """
426 
    Returns a list of orders that were returned by courier.
427 
 
428 
    Parameters:
429 
     - providerId
430 
    """
431 
    pass
432 
 
1246 chandransh 433 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
434 
    """
435 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 436 
 
1246 chandransh 437 
    Parameters:
438 
     - providerId
439 
     - undeliveredOrders
440 
    """
441 
    pass
442 
 
4910 phani.kuma 443 
  def getNonDeliveredOrdersbyCourier(self, providerId):
444 
    """
445 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
446 
 
447 
    Parameters:
448 
     - providerId
449 
    """
450 
    pass
451 
 
452 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
453 
    """
454 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
455 
 
456 
    Parameters:
457 
     - providerId
458 
     - local_connected_orders
459 
    """
460 
    pass
461 
 
462 
  def getOrdersNotLocalConnected(self, providerId):
463 
    """
464 
    Returns a list of orders that were picked up or shipped but pending local connection.
465 
 
466 
    Parameters:
467 
     - providerId
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - destination_city_reached_orders
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - first_atdl_orders
488 
    """
489 
    pass
490 
 
1408 ankur.sing 491 
  def getUndeliveredOrders(self, providerId, warehouseId):
492 
    """
493 
    Returns the list of orders whose delivery time has passed but have not been
494 
    delivered yet for the given provider and warehouse. To get a complete list of
495 
    undelivered orders, pass them as -1.
496 
    Returns an empty list if no such orders exist.
3431 rajveer 497 
 
1408 ankur.sing 498 
    Parameters:
499 
     - providerId
500 
     - warehouseId
501 
    """
502 
    pass
503 
 
4783 phani.kuma 504 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
505 
    """
506 
    Returns the list of orders whose expected delivery date has passed but have not been
507 
    delivered yet.
508 
    Returns an empty list if no such orders exist.
509 
    """
510 
    pass
511 
 
2536 chandransh 512 
  def toggleDOAFlag(self, orderId):
513 
    """
514 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
515 
    Returns the final flag status.
516 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 517 
 
2536 chandransh 518 
    Parameters:
519 
     - orderId
520 
    """
521 
    pass
1886 ankur.sing 522 
 
4712 rajveer 523 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
524 
    """
525 
    Parameters:
526 
     - orderId
527 
     - deliveryTimestamp
528 
     - receiver
529 
    """
530 
    pass
531 
 
5553 rajveer 532 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
533 
    """
534 
    Parameters:
535 
     - orderId
536 
     - deliveryTimestamp
537 
    """
538 
    pass
539 
 
4454 rajveer 540 
  def markOrderDoaRequestReceived(self, orderId):
541 
    """
542 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
543 
 
544 
    Parameters:
545 
     - orderId
546 
    """
547 
    pass
548 
 
549 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
550 
    """
551 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
552 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
553 
 
554 
    Parameters:
555 
     - orderId
556 
     - isAuthorized
557 
    """
558 
    pass
559 
 
4488 rajveer 560 
  def markOrderReturnRequestReceived(self, orderId):
561 
    """
562 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
563 
 
564 
    Parameters:
565 
     - orderId
566 
    """
567 
    pass
568 
 
569 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
570 
    """
571 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
572 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
573 
 
574 
    Parameters:
575 
     - orderId
576 
     - isAuthorized
577 
    """
578 
    pass
579 
 
4579 rajveer 580 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 581 
    """
582 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 583 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
584 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 585 
    For any other status, it returns false.
586 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 587 
 
2536 chandransh 588 
    Parameters:
589 
     - orderId
4579 rajveer 590 
     - providerId
2536 chandransh 591 
    """
592 
    pass
593 
 
4602 rajveer 594 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 595 
    """
4452 rajveer 596 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 597 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
598 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
599 
    	3. Returns true
2591 chandransh 600 
    If the order is in any other status, it returns false.
2536 chandransh 601 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 602 
 
2536 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - pickupNumber
4602 rajveer 606 
     - providerId
2536 chandransh 607 
    """
608 
    pass
609 
 
2764 chandransh 610 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
611 
    """
612 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 613 
 
2764 chandransh 614 
    Parameters:
615 
     - providerId
616 
     - pickupDetails
617 
    """
618 
    pass
619 
 
4910 phani.kuma 620 
  def getDoasNotPickedUp(self, providerId):
621 
    """
622 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
623 
 
624 
    Parameters:
625 
     - providerId
626 
    """
627 
    pass
628 
 
4741 phani.kuma 629 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
630 
    """
631 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
632 
 
633 
    Parameters:
634 
     - providerId
635 
     - pickupDetails
636 
    """
637 
    pass
638 
 
4910 phani.kuma 639 
  def getReturnOrdersNotPickedUp(self, providerId):
640 
    """
641 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
642 
 
643 
    Parameters:
644 
     - providerId
645 
    """
646 
    pass
647 
 
4479 rajveer 648 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 649 
    """
4452 rajveer 650 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 651 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 652 
    If the order is in any other state, it returns false.
653 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 654 
 
2591 chandransh 655 
    Parameters:
656 
     - orderId
4479 rajveer 657 
     - receiveCondition
2591 chandransh 658 
    """
659 
    pass
2536 chandransh 660 
 
2591 chandransh 661 
  def validateDoa(self, orderId, isValid):
662 
    """
4452 rajveer 663 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 664 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 665 
    If the order is in any other state, it returns false.
666 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 667 
 
2591 chandransh 668 
    Parameters:
669 
     - orderId
670 
     - isValid
671 
    """
672 
    pass
673 
 
4495 rajveer 674 
  def validateReturnProduct(self, orderId, isUsable):
675 
    """
676 
    Parameters:
677 
     - orderId
678 
     - isUsable
679 
    """
680 
    pass
681 
 
2616 chandransh 682 
  def reshipOrder(self, orderId):
683 
    """
4484 rajveer 684 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 685 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 686 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 687 
 
688 
    If the order is in DOA_CERT_VALID state, it does the following:
689 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
690 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 691 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 692 
 
2616 chandransh 693 
    Returns the id of the newly created order.
3431 rajveer 694 
 
2616 chandransh 695 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 696 
 
2616 chandransh 697 
    Parameters:
698 
     - orderId
699 
    """
700 
    pass
2591 chandransh 701 
 
3226 chandransh 702 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 703 
    """
4484 rajveer 704 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 705 
    	1. Creates a refund request for batch processing.
706 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 707 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 708 
 
2616 chandransh 709 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
710 
    	1. Creates a refund request for batch processing.
3226 chandransh 711 
    	2. Cancels the reservation of the item in the warehouse.
712 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 713 
 
3226 chandransh 714 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
715 
    	1. Cancels the reservation of the item in the warehouse.
716 
    	2. Marks the current order as CANCELED.
717 
 
718 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
719 
 
2616 chandransh 720 
    Returns True if it is successful, False otherwise.
3431 rajveer 721 
 
2616 chandransh 722 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 723 
 
2616 chandransh 724 
    Parameters:
725 
     - orderId
3226 chandransh 726 
     - refundedBy
727 
     - reason
2616 chandransh 728 
    """
729 
    pass
730 
 
2690 chandransh 731 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
732 
    """
733 
    Get all return orders created between the from and to dates for the given warehouse.
734 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 735 
 
2690 chandransh 736 
    Parameters:
737 
     - warehouseId
738 
     - fromDate
739 
     - toDate
740 
    """
741 
    pass
2616 chandransh 742 
 
5481 phani.kuma 743 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates.
746 
 
747 
    Parameters:
748 
     - onlyNotProcessed
749 
     - fromDate
750 
     - toDate
751 
    """
752 
    pass
753 
 
2700 chandransh 754 
  def getReturnOrder(self, id):
755 
    """
756 
    Returns the ReturnOrder corresponding to the given id.
757 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 758 
 
2700 chandransh 759 
    Parameters:
760 
     - id
761 
    """
762 
    pass
763 
 
2690 chandransh 764 
  def processReturn(self, returnOrderId):
765 
    """
766 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 767 
 
2690 chandransh 768 
    Parameters:
769 
     - returnOrderId
770 
    """
771 
    pass
772 
 
3451 chandransh 773 
  def updateWeight(self, orderId, weight):
774 
    """
775 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 776 
 
3451 chandransh 777 
    Parameters:
778 
     - orderId
779 
     - weight
780 
    """
781 
    pass
782 
 
3469 chandransh 783 
  def changeItem(self, orderId, itemId):
784 
    """
785 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
786 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 787 
 
3469 chandransh 788 
    Parameters:
789 
     - orderId
790 
     - itemId
791 
    """
792 
    pass
793 
 
794 
  def shiftToWarehouse(self, orderId, warehouseId):
795 
    """
796 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
797 
 
798 
    Parameters:
799 
     - orderId
800 
     - warehouseId
801 
    """
802 
    pass
803 
 
4647 rajveer 804 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 805 
    """
806 
    Adds the given delay reason to the given order.
3986 chandransh 807 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 808 
    Raises an exception if no order with the given id can be found.
3469 chandransh 809 
 
3553 chandransh 810 
    Parameters:
811 
     - orderId
812 
     - delayReason
3986 chandransh 813 
     - furtherDelay
4647 rajveer 814 
     - delayReasonText
3553 chandransh 815 
    """
816 
    pass
817 
 
3956 chandransh 818 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
819 
    """
820 
    Marks the COD orders with given AWB nos. as having been processed.
821 
    Updates the captured amount for the corresponding payment.
3553 chandransh 822 
 
3956 chandransh 823 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
824 
    1. There is no order corresponding to an AWB number.
825 
    2. The captured amount for a payment exceeds the total payment.
826 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
827 
 
828 
    Parameters:
829 
     - collectedAmountMap
830 
     - xferBy
831 
     - xferTxnId
832 
     - xferDate
833 
    """
834 
    pass
835 
 
4008 mandeep.dh 836 
  def getTransactionsRequiringExtraProcessing(self, category):
837 
    """
4065 mandeep.dh 838 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 839 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 840 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 841 
 
4008 mandeep.dh 842 
    Parameters:
843 
     - category
844 
    """
845 
    pass
846 
 
847 
  def markTransactionAsProcessed(self, transactionId, category):
848 
    """
849 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 850 
    It essentially deletes the transaction id record for a particular
851 
    processing type category (if present) from DB.
852 
    This is currently used by CRM application.
4008 mandeep.dh 853 
 
854 
    Parameters:
855 
     - transactionId
856 
     - category
857 
    """
858 
    pass
859 
 
4018 chandransh 860 
  def getItemWiseRiskyOrdersCount(self, ):
861 
    """
862 
    Returns a map containing the number of risky orders keyed by item id. A risky order
863 
    is defined as one whose shipping date is about to expire.
864 
    """
865 
    pass
4008 mandeep.dh 866 
 
4295 varun.gupt 867 
  def getOrdersForItemIds(self, itemIds):
868 
    """
869 
    Returns a list of all orders which have items with given id
870 
 
871 
    Parameters:
872 
     - itemIds
873 
    """
874 
    pass
875 
 
4247 rajveer 876 
  def markOrderCancellationRequestReceived(self, orderId):
877 
    """
878 
    Mark order as cancellation request received. If customer sends request of cancellation of
879 
    a particular order, this method will be called. It will just change status of the order
880 
    depending on its current status. It also records the previous status, so that we can move
881 
    back to that status if cancellation request is denied.
4018 chandransh 882 
 
4247 rajveer 883 
    Parameters:
884 
     - orderId
885 
    """
886 
    pass
887 
 
888 
  def markOrderCancellationRequestConfirmed(self, orderId):
889 
    """
890 
    If we decide to to cancel order, CRM will call this method to move the status of order to
891 
    cancellation request confirmed. After this OM will be able to cancel the order.
892 
 
893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestDenied(self, orderId):
899 
    """
900 
    If we decide to not to cancel order, we will move the order ro previous status.
901 
 
902 
    Parameters:
903 
     - orderId
904 
    """
905 
    pass
906 
 
4258 rajveer 907 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 908 
    """
4258 rajveer 909 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
910 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 911 
 
912 
    Parameters:
4258 rajveer 913 
     - transactionId
4247 rajveer 914 
    """
915 
    pass
916 
 
4259 anupam.sin 917 
  def refundTransaction(self, transactionId, refundedBy, reason):
918 
    """
919 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
920 
    need to be cancelled
4247 rajveer 921 
 
4259 anupam.sin 922 
    Parameters:
923 
     - transactionId
924 
     - refundedBy
925 
     - reason
926 
    """
927 
    pass
928 
 
4324 mandeep.dh 929 
  def updateShipmentAddress(self, orderId, addressId):
930 
    """
931 
    Updates shipment address of an order. Delivery and shipping date estimates
932 
    etc. are also updated here.
933 
 
934 
    Throws TransactionServiceException in case address change is not
935 
    possible due to certain reasons such as new pincode in address is
936 
    not serviceable etc.
937 
 
938 
    Parameters:
939 
     - orderId
940 
     - addressId
941 
    """
942 
    pass
943 
 
4285 rajveer 944 
  def acceptOrdersForItemId(self, itemId, inventory):
945 
    """
946 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
947 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 948 
 
4285 rajveer 949 
    Parameters:
950 
     - itemId
951 
     - inventory
952 
    """
953 
    pass
954 
 
4369 rajveer 955 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 956 
    """
957 
    Parameters:
958 
     - vendorId
959 
     - itemId
960 
     - quantity
961 
     - estimate
4369 rajveer 962 
     - isReminder
4303 rajveer 963 
    """
964 
    pass
4285 rajveer 965 
 
4369 rajveer 966 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 967 
    """
968 
    Parameters:
969 
     - vendorId
970 
     - itemId
971 
     - quantity
972 
     - estimate
4369 rajveer 973 
     - isReminder
4303 rajveer 974 
    """
975 
    pass
976 
 
4369 rajveer 977 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 978 
    """
979 
    Parameters:
980 
     - vendorId
981 
     - itemId
982 
     - quantity
983 
     - estimate
4369 rajveer 984 
     - isReminder
4303 rajveer 985 
    """
986 
    pass
987 
 
4369 rajveer 988 
  def markOrdersAsTimeout(self, vendorId):
989 
    """
990 
    Parameters:
991 
     - vendorId
992 
    """
993 
    pass
4303 rajveer 994 
 
4662 rajveer 995 
  def markOrderAsLostInTransit(self, orderId):
996 
    """
997 
    Mark order as LOST_IN_TRANSIT
998 
 
999 
    Parameters:
1000 
     - orderId
1001 
    """
1002 
    pass
1003 
 
4386 anupam.sin 1004 
  def getOrderForAwb(self, awb):
1005 
    """
1006 
    Returns the order corresponding to an AWB number
4369 rajveer 1007 
 
4386 anupam.sin 1008 
    Parameters:
1009 
     - awb
1010 
    """
1011 
    pass
1012 
 
4910 phani.kuma 1013 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1014 
    """
4910 phani.kuma 1015 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1016 
 
4506 phani.kuma 1017 
    Parameters:
1018 
     - logistics_provider_id
4910 phani.kuma 1019 
     - order_status_list
4506 phani.kuma 1020 
    """
1021 
    pass
1022 
 
4600 varun.gupt 1023 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1024 
    """
1025 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1026 
 
4600 varun.gupt 1027 
    Parameters:
1028 
     - vendorId
1029 
     - billingDateFrom
1030 
     - billingDateTo
1031 
    """
1032 
    pass
1033 
 
4607 rajveer 1034 
  def getSlippedSippingDateOrders(self, ):
1035 
    pass
1036 
 
4709 rajveer 1037 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1038 
    """
1039 
    Parameters:
1040 
     - cancelDateFrom
1041 
     - cancelDateTo
1042 
    """
1043 
    pass
1044 
 
4600 varun.gupt 1045 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1046 
    """
1047 
    Parameters:
1048 
     - mapAWBAndAmount
1049 
    """
1050 
    pass
1051 
 
4905 varun.gupt 1052 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1053 
    """
1054 
    Parameters:
1055 
     - settlementDate
1056 
     - paymentGatewayId
4905 varun.gupt 1057 
     - referenceId
4600 varun.gupt 1058 
     - serviceTax
1059 
     - otherCharges
1060 
     - netCollection
1061 
    """
1062 
    pass
1063 
 
1064 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1065 
    """
1066 
    Parameters:
1067 
     - settlementId
1068 
     - settlementDate
1069 
     - transactionDateFrom
1070 
     - transactionDateTo
1071 
     - amount
1072 
    """
1073 
    pass
1074 
 
5386 phani.kuma 1075 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1076 
    """
1077 
    Parameters:
5189 varun.gupt 1078 
     - referenceId
1079 
     - isRefund
4600 varun.gupt 1080 
    """
1081 
    pass
1082 
 
5386 phani.kuma 1083 
  def getSettlementForCod(self, orderId, isRefund):
1084 
    """
1085 
    Parameters:
1086 
     - orderId
1087 
     - isRefund
1088 
    """
1089 
    pass
1090 
 
4600 varun.gupt 1091 
  def getEBSSettlementSummaries(self, ):
1092 
    pass
1093 
 
1094 
  def markEBSSettlementUploaded(self, settlementId):
1095 
    """
1096 
    Parameters:
1097 
     - settlementId
1098 
    """
1099 
    pass
1100 
 
1101 
  def getEBSSettlementDate(self, settlementId):
1102 
    """
1103 
    Parameters:
1104 
     - settlementId
1105 
    """
1106 
    pass
1107 
 
4715 varun.gupt 1108 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1109 
    """
1110 
    Parameters:
1111 
     - settlementDateFrom
1112 
     - settlementDateTo
1113 
     - isRefund
1114 
    """
1115 
    pass
4600 varun.gupt 1116 
 
4715 varun.gupt 1117 
  def getReshippedOrderIds(self, orderIds):
1118 
    """
1119 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1120 
 
1121 
    Parameters:
1122 
     - orderIds
1123 
    """
1124 
    pass
1125 
 
5481 phani.kuma 1126 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1127 
    """
1128 
    Parameters:
1129 
     - vendorId
5481 phani.kuma 1130 
     - onlyVendorNotPaid
1131 
     - billingDateFrom
1132 
     - billingDateTo
4875 varun.gupt 1133 
    """
1134 
    pass
4757 mandeep.dh 1135 
 
5031 varun.gupt 1136 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1137 
    """
1138 
    Parameters:
1139 
     - startDate
1140 
     - endDate
1141 
    """
1142 
    pass
4875 varun.gupt 1143 
 
5067 varun.gupt 1144 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1145 
    """
1146 
    Parameters:
1147 
     - status
1148 
     - startDatetime
1149 
     - endDatetime
1150 
    """
1151 
    pass
5031 varun.gupt 1152 
 
5348 anupam.sin 1153 
  def updateCODAgent(self, agent, orderId):
1154 
    """
1155 
    Updates the agent who handled the COD verification call
1156 
 
1157 
    Parameters:
1158 
     - agent
1159 
     - orderId
1160 
    """
1161 
    pass
1162 
 
5099 varun.gupt 1163 
  def updateOrderAsPaidToVendor(self, orderId):
1164 
    """
1165 
    Parameters:
1166 
     - orderId
1167 
    """
1168 
    pass
5067 varun.gupt 1169 
 
5386 phani.kuma 1170 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1171 
    """
1172 
    Parameters:
1173 
     - orderId
1174 
    """
1175 
    pass
1176 
 
5208 varun.gupt 1177 
  def getRefundedOrdersMarkedPaid(self, ):
1178 
    pass
5099 varun.gupt 1179 
 
5447 anupam.sin 1180 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1181 
    """
1182 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1183 
 
5447 anupam.sin 1184 
 
1185 
    Parameters:
1186 
     - minOrderId
1187 
     - maxOrderId
1188 
    """
1189 
    pass
1190 
 
5527 anupam.sin 1191 
  def getAllAttributesForOrderId(self, orderId):
1192 
    """
1193 
    gets all attributes for a given orderId
5447 anupam.sin 1194 
 
5527 anupam.sin 1195 
    Parameters:
1196 
     - orderId
1197 
    """
1198 
    pass
1199 
 
1200 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1201 
    """
1202 
    sets attributes for all orders in a transaction
1203 
 
1204 
    Parameters:
1205 
     - transactionId
1206 
     - attribute
1207 
    """
1208 
    pass
1209 
 
5553 rajveer 1210 
  def getReceivePendingOrders(self, storeId):
1211 
    """
1212 
    Parameters:
1213 
     - storeId
1214 
    """
1215 
    pass
5527 anupam.sin 1216 
 
5553 rajveer 1217 
  def getReceivedAtStoreOrders(self, storeId):
1218 
    """
1219 
    Parameters:
1220 
     - storeId
1221 
    """
1222 
    pass
1223 
 
5593 mandeep.dh 1224 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1225 
    """
1226 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1227 
    invoked while scanning IN of items.
5553 rajveer 1228 
 
5593 mandeep.dh 1229 
    Parameters:
1230 
     - itemId
1231 
     - quantity
1232 
     - fulfilmentWarehouseId
1233 
     - billingWarehouseId
1234 
    """
1235 
    pass
1236 
 
1237 
 
3376 rajveer 1238 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1239 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1240 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1241 
 
1242 
  def createTransaction(self, transaction):
1243 
    """
1244 
    Parameters:
1245 
     - transaction
1246 
    """
1247 
    self.send_createTransaction(transaction)
132 ashish 1248 
    return self.recv_createTransaction()
94 ashish 1249 
 
1250 
  def send_createTransaction(self, transaction):
1251 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1252 
    args = createTransaction_args()
1253 
    args.transaction = transaction
1254 
    args.write(self._oprot)
1255 
    self._oprot.writeMessageEnd()
1256 
    self._oprot.trans.flush()
1257 
 
1258 
  def recv_createTransaction(self, ):
1259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1260 
    if mtype == TMessageType.EXCEPTION:
1261 
      x = TApplicationException()
1262 
      x.read(self._iprot)
1263 
      self._iprot.readMessageEnd()
1264 
      raise x
1265 
    result = createTransaction_result()
1266 
    result.read(self._iprot)
1267 
    self._iprot.readMessageEnd()
3431 rajveer 1268 
    if result.success is not None:
132 ashish 1269 
      return result.success
3431 rajveer 1270 
    if result.ex is not None:
94 ashish 1271 
      raise result.ex
132 ashish 1272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1273 
 
1274 
  def getTransaction(self, id):
1275 
    """
1276 
    Parameters:
1277 
     - id
1278 
    """
1279 
    self.send_getTransaction(id)
1280 
    return self.recv_getTransaction()
1281 
 
1282 
  def send_getTransaction(self, id):
1283 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1284 
    args = getTransaction_args()
1285 
    args.id = id
1286 
    args.write(self._oprot)
1287 
    self._oprot.writeMessageEnd()
1288 
    self._oprot.trans.flush()
1289 
 
1290 
  def recv_getTransaction(self, ):
1291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1292 
    if mtype == TMessageType.EXCEPTION:
1293 
      x = TApplicationException()
1294 
      x.read(self._iprot)
1295 
      self._iprot.readMessageEnd()
1296 
      raise x
1297 
    result = getTransaction_result()
1298 
    result.read(self._iprot)
1299 
    self._iprot.readMessageEnd()
3431 rajveer 1300 
    if result.success is not None:
94 ashish 1301 
      return result.success
3431 rajveer 1302 
    if result.ex is not None:
94 ashish 1303 
      raise result.ex
1304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1305 
 
1306 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1307 
    """
1308 
    Parameters:
1309 
     - customerId
1310 
     - from_date
1311 
     - to_date
1312 
     - status
1313 
    """
1314 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1315 
    return self.recv_getTransactionsForCustomer()
1316 
 
1317 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1318 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1319 
    args = getTransactionsForCustomer_args()
1320 
    args.customerId = customerId
1321 
    args.from_date = from_date
1322 
    args.to_date = to_date
1323 
    args.status = status
1324 
    args.write(self._oprot)
1325 
    self._oprot.writeMessageEnd()
1326 
    self._oprot.trans.flush()
1327 
 
1328 
  def recv_getTransactionsForCustomer(self, ):
1329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1330 
    if mtype == TMessageType.EXCEPTION:
1331 
      x = TApplicationException()
1332 
      x.read(self._iprot)
1333 
      self._iprot.readMessageEnd()
1334 
      raise x
1335 
    result = getTransactionsForCustomer_result()
1336 
    result.read(self._iprot)
1337 
    self._iprot.readMessageEnd()
3431 rajveer 1338 
    if result.success is not None:
94 ashish 1339 
      return result.success
3431 rajveer 1340 
    if result.ex is not None:
94 ashish 1341 
      raise result.ex
1342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1343 
 
132 ashish 1344 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1345 
    """
1346 
    Parameters:
1347 
     - shoppingCartId
1348 
    """
1349 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1350 
    return self.recv_getTransactionsForShoppingCartId()
1351 
 
1352 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1353 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1354 
    args = getTransactionsForShoppingCartId_args()
1355 
    args.shoppingCartId = shoppingCartId
1356 
    args.write(self._oprot)
1357 
    self._oprot.writeMessageEnd()
1358 
    self._oprot.trans.flush()
1359 
 
1360 
  def recv_getTransactionsForShoppingCartId(self, ):
1361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1362 
    if mtype == TMessageType.EXCEPTION:
1363 
      x = TApplicationException()
1364 
      x.read(self._iprot)
1365 
      self._iprot.readMessageEnd()
1366 
      raise x
1367 
    result = getTransactionsForShoppingCartId_result()
1368 
    result.read(self._iprot)
1369 
    self._iprot.readMessageEnd()
3431 rajveer 1370 
    if result.success is not None:
132 ashish 1371 
      return result.success
3431 rajveer 1372 
    if result.ex is not None:
132 ashish 1373 
      raise result.ex
1374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1375 
 
94 ashish 1376 
  def getTransactionStatus(self, transactionId):
1377 
    """
1378 
    Parameters:
1379 
     - transactionId
1380 
    """
1381 
    self.send_getTransactionStatus(transactionId)
1382 
    return self.recv_getTransactionStatus()
1383 
 
1384 
  def send_getTransactionStatus(self, transactionId):
1385 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1386 
    args = getTransactionStatus_args()
1387 
    args.transactionId = transactionId
1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
1392 
  def recv_getTransactionStatus(self, ):
1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
1399 
    result = getTransactionStatus_result()
1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
3431 rajveer 1402 
    if result.success is not None:
94 ashish 1403 
      return result.success
3431 rajveer 1404 
    if result.ex is not None:
94 ashish 1405 
      raise result.ex
1406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1407 
 
5527 anupam.sin 1408 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1409 
    """
1410 
    Parameters:
1411 
     - transactionId
1412 
     - status
1413 
     - description
5527 anupam.sin 1414 
     - pickUp
1415 
     - orderType
94 ashish 1416 
    """
5527 anupam.sin 1417 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1418 
    return self.recv_changeTransactionStatus()
1419 
 
5527 anupam.sin 1420 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1421 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1422 
    args = changeTransactionStatus_args()
1423 
    args.transactionId = transactionId
1424 
    args.status = status
1425 
    args.description = description
5527 anupam.sin 1426 
    args.pickUp = pickUp
1427 
    args.orderType = orderType
94 ashish 1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_changeTransactionStatus(self, ):
1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
1439 
    result = changeTransactionStatus_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
3431 rajveer 1442 
    if result.success is not None:
94 ashish 1443 
      return result.success
3431 rajveer 1444 
    if result.ex is not None:
94 ashish 1445 
      raise result.ex
1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1447 
 
1398 varun.gupt 1448 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1449 
    """
1450 
    Parameters:
1451 
     - transactionId
1452 
    """
1398 varun.gupt 1453 
    self.send_enqueueTransactionInfoEmail(transactionId)
1454 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1455 
 
1398 varun.gupt 1456 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1457 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1458 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1459 
    args.transactionId = transactionId
1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1398 varun.gupt 1464 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1398 varun.gupt 1471 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
3431 rajveer 1474 
    if result.success is not None:
1382 varun.gupt 1475 
      return result.success
3431 rajveer 1476 
    if result.ex is not None:
1382 varun.gupt 1477 
      raise result.ex
1398 varun.gupt 1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1479 
 
4801 anupam.sin 1480 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1481 
    """
1482 
    Parameters:
4801 anupam.sin 1483 
     - statuses
483 rajveer 1484 
     - from_date
1485 
     - to_date
1486 
     - warehouse_id
94 ashish 1487 
    """
4801 anupam.sin 1488 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1489 
    return self.recv_getAllOrders()
94 ashish 1490 
 
4801 anupam.sin 1491 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1492 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1493 
    args = getAllOrders_args()
4801 anupam.sin 1494 
    args.statuses = statuses
483 rajveer 1495 
    args.from_date = from_date
1496 
    args.to_date = to_date
1497 
    args.warehouse_id = warehouse_id
94 ashish 1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
483 rajveer 1502 
  def recv_getAllOrders(self, ):
94 ashish 1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
483 rajveer 1509 
    result = getAllOrders_result()
94 ashish 1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
3431 rajveer 1512 
    if result.success is not None:
94 ashish 1513 
      return result.success
3431 rajveer 1514 
    if result.ex is not None:
94 ashish 1515 
      raise result.ex
483 rajveer 1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1517 
 
4133 chandransh 1518 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1519 
    """
1520 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1521 
    Pass the status as null and the limit as 0 to ignore them.
1522 
 
1523 
    Parameters:
1524 
     - statuses
1525 
     - offset
1526 
     - limit
1527 
     - warehouse_id
1528 
    """
1529 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1530 
    return self.recv_getOrdersInBatch()
1531 
 
1532 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1533 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1534 
    args = getOrdersInBatch_args()
1535 
    args.statuses = statuses
1536 
    args.offset = offset
1537 
    args.limit = limit
1538 
    args.warehouse_id = warehouse_id
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_getOrdersInBatch(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = getOrdersInBatch_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    if result.success is not None:
1554 
      return result.success
1555 
    if result.ex is not None:
1556 
      raise result.ex
1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1558 
 
1559 
  def getOrderCount(self, statuses, warehouseId):
1560 
    """
1561 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1562 
 
1563 
    Parameters:
1564 
     - statuses
1565 
     - warehouseId
1566 
    """
1567 
    self.send_getOrderCount(statuses, warehouseId)
1568 
    return self.recv_getOrderCount()
1569 
 
1570 
  def send_getOrderCount(self, statuses, warehouseId):
1571 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1572 
    args = getOrderCount_args()
1573 
    args.statuses = statuses
1574 
    args.warehouseId = warehouseId
1575 
    args.write(self._oprot)
1576 
    self._oprot.writeMessageEnd()
1577 
    self._oprot.trans.flush()
1578 
 
1579 
  def recv_getOrderCount(self, ):
1580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1581 
    if mtype == TMessageType.EXCEPTION:
1582 
      x = TApplicationException()
1583 
      x.read(self._iprot)
1584 
      self._iprot.readMessageEnd()
1585 
      raise x
1586 
    result = getOrderCount_result()
1587 
    result.read(self._iprot)
1588 
    self._iprot.readMessageEnd()
1589 
    if result.success is not None:
1590 
      return result.success
1591 
    if result.ex is not None:
1592 
      raise result.ex
1593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1594 
 
999 varun.gupt 1595 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1596 
    """
1132 chandransh 1597 
    Returns orders within a range of their billing dates
3431 rajveer 1598 
 
999 varun.gupt 1599 
    Parameters:
1600 
     - status
1601 
     - start_billing_date
1602 
     - end_billing_date
1603 
     - warehouse_id
1604 
    """
1605 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1606 
    return self.recv_getOrdersByBillingDate()
1607 
 
1608 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1609 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1610 
    args = getOrdersByBillingDate_args()
1611 
    args.status = status
1612 
    args.start_billing_date = start_billing_date
1613 
    args.end_billing_date = end_billing_date
1614 
    args.warehouse_id = warehouse_id
1615 
    args.write(self._oprot)
1616 
    self._oprot.writeMessageEnd()
1617 
    self._oprot.trans.flush()
1618 
 
1619 
  def recv_getOrdersByBillingDate(self, ):
1620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1621 
    if mtype == TMessageType.EXCEPTION:
1622 
      x = TApplicationException()
1623 
      x.read(self._iprot)
1624 
      self._iprot.readMessageEnd()
1625 
      raise x
1626 
    result = getOrdersByBillingDate_result()
1627 
    result.read(self._iprot)
1628 
    self._iprot.readMessageEnd()
3431 rajveer 1629 
    if result.success is not None:
999 varun.gupt 1630 
      return result.success
3431 rajveer 1631 
    if result.ex is not None:
999 varun.gupt 1632 
      raise result.ex
1633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1634 
 
3451 chandransh 1635 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1636 
    """
1637 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1638 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1639 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1640 
 
3427 chandransh 1641 
    Parameters:
1642 
     - fromShippingDate
1643 
     - toShippingDate
1644 
     - providerId
1645 
     - warehouseId
3451 chandransh 1646 
     - cod
3427 chandransh 1647 
    """
3451 chandransh 1648 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1649 
    return self.recv_getOrdersByShippingDate()
1650 
 
3451 chandransh 1651 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1652 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1653 
    args = getOrdersByShippingDate_args()
1654 
    args.fromShippingDate = fromShippingDate
1655 
    args.toShippingDate = toShippingDate
1656 
    args.providerId = providerId
1657 
    args.warehouseId = warehouseId
3451 chandransh 1658 
    args.cod = cod
3427 chandransh 1659 
    args.write(self._oprot)
1660 
    self._oprot.writeMessageEnd()
1661 
    self._oprot.trans.flush()
1662 
 
1663 
  def recv_getOrdersByShippingDate(self, ):
1664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1665 
    if mtype == TMessageType.EXCEPTION:
1666 
      x = TApplicationException()
1667 
      x.read(self._iprot)
1668 
      self._iprot.readMessageEnd()
1669 
      raise x
1670 
    result = getOrdersByShippingDate_result()
1671 
    result.read(self._iprot)
1672 
    self._iprot.readMessageEnd()
3431 rajveer 1673 
    if result.success is not None:
3427 chandransh 1674 
      return result.success
3431 rajveer 1675 
    if result.ex is not None:
3427 chandransh 1676 
      raise result.ex
1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1678 
 
1382 varun.gupt 1679 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1680 
    """
1681 
    Returns order ids for orders which can be returned
3431 rajveer 1682 
 
1382 varun.gupt 1683 
    Parameters:
1684 
     - customer_id
1685 
     - limit
1686 
    """
1687 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1688 
    return self.recv_getReturnableOrdersForCustomer()
1689 
 
1690 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1691 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1692 
    args = getReturnableOrdersForCustomer_args()
1693 
    args.customer_id = customer_id
1694 
    args.limit = limit
1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
1699 
  def recv_getReturnableOrdersForCustomer(self, ):
1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
1706 
    result = getReturnableOrdersForCustomer_result()
1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
3431 rajveer 1709 
    if result.success is not None:
1382 varun.gupt 1710 
      return result.success
3431 rajveer 1711 
    if result.ex is not None:
1382 varun.gupt 1712 
      raise result.ex
1713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1714 
 
1715 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1716 
    """
1717 
    Returns order ids for orders which can be cancelled
3431 rajveer 1718 
 
1382 varun.gupt 1719 
    Parameters:
1720 
     - customer_id
1721 
     - limit
1722 
    """
1723 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1724 
    return self.recv_getCancellableOrdersForCustomer()
1725 
 
1726 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1727 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1728 
    args = getCancellableOrdersForCustomer_args()
1729 
    args.customer_id = customer_id
1730 
    args.limit = limit
1731 
    args.write(self._oprot)
1732 
    self._oprot.writeMessageEnd()
1733 
    self._oprot.trans.flush()
1734 
 
1735 
  def recv_getCancellableOrdersForCustomer(self, ):
1736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1737 
    if mtype == TMessageType.EXCEPTION:
1738 
      x = TApplicationException()
1739 
      x.read(self._iprot)
1740 
      self._iprot.readMessageEnd()
1741 
      raise x
1742 
    result = getCancellableOrdersForCustomer_result()
1743 
    result.read(self._iprot)
1744 
    self._iprot.readMessageEnd()
3431 rajveer 1745 
    if result.success is not None:
1382 varun.gupt 1746 
      return result.success
3431 rajveer 1747 
    if result.ex is not None:
1382 varun.gupt 1748 
      raise result.ex
1749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1750 
 
483 rajveer 1751 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1752 
    """
1753 
    Parameters:
483 rajveer 1754 
     - orderId
1755 
     - status
1756 
     - description
94 ashish 1757 
    """
483 rajveer 1758 
    self.send_changeOrderStatus(orderId, status, description)
1759 
    return self.recv_changeOrderStatus()
94 ashish 1760 
 
483 rajveer 1761 
  def send_changeOrderStatus(self, orderId, status, description):
1762 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1763 
    args = changeOrderStatus_args()
1764 
    args.orderId = orderId
1765 
    args.status = status
1766 
    args.description = description
94 ashish 1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
483 rajveer 1771 
  def recv_changeOrderStatus(self, ):
94 ashish 1772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1773 
    if mtype == TMessageType.EXCEPTION:
1774 
      x = TApplicationException()
1775 
      x.read(self._iprot)
1776 
      self._iprot.readMessageEnd()
1777 
      raise x
483 rajveer 1778 
    result = changeOrderStatus_result()
94 ashish 1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
3431 rajveer 1781 
    if result.success is not None:
94 ashish 1782 
      return result.success
3431 rajveer 1783 
    if result.ex is not None:
94 ashish 1784 
      raise result.ex
483 rajveer 1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1786 
 
1528 ankur.sing 1787 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1788 
    """
1528 ankur.sing 1789 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1790 
    only user who owns the transaction can view its order details.
3431 rajveer 1791 
 
94 ashish 1792 
    Parameters:
1793 
     - transactionId
1528 ankur.sing 1794 
     - customerId
94 ashish 1795 
    """
1528 ankur.sing 1796 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1797 
    return self.recv_getOrdersForTransaction()
94 ashish 1798 
 
1528 ankur.sing 1799 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1800 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1801 
    args = getOrdersForTransaction_args()
94 ashish 1802 
    args.transactionId = transactionId
1528 ankur.sing 1803 
    args.customerId = customerId
94 ashish 1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
483 rajveer 1808 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
483 rajveer 1815 
    result = getOrdersForTransaction_result()
94 ashish 1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
3431 rajveer 1818 
    if result.success is not None:
94 ashish 1819 
      return result.success
3431 rajveer 1820 
    if result.ex is not None:
94 ashish 1821 
      raise result.ex
483 rajveer 1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1823 
 
3014 chandransh 1824 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1825 
    """
3014 chandransh 1826 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1827 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1828 
 
94 ashish 1829 
    Parameters:
483 rajveer 1830 
     - customerId
1831 
     - from_date
1832 
     - to_date
3014 chandransh 1833 
     - statuses
94 ashish 1834 
    """
3014 chandransh 1835 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1836 
    return self.recv_getOrdersForCustomer()
94 ashish 1837 
 
3014 chandransh 1838 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1839 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1840 
    args = getOrdersForCustomer_args()
1841 
    args.customerId = customerId
1842 
    args.from_date = from_date
1843 
    args.to_date = to_date
3014 chandransh 1844 
    args.statuses = statuses
94 ashish 1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
483 rajveer 1849 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
483 rajveer 1856 
    result = getOrdersForCustomer_result()
94 ashish 1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
3431 rajveer 1859 
    if result.success is not None:
94 ashish 1860 
      return result.success
3431 rajveer 1861 
    if result.ex is not None:
94 ashish 1862 
      raise result.ex
483 rajveer 1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1864 
 
483 rajveer 1865 
  def createOrder(self, order):
94 ashish 1866 
    """
1867 
    Parameters:
483 rajveer 1868 
     - order
94 ashish 1869 
    """
483 rajveer 1870 
    self.send_createOrder(order)
1871 
    return self.recv_createOrder()
94 ashish 1872 
 
483 rajveer 1873 
  def send_createOrder(self, order):
1874 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1875 
    args = createOrder_args()
1876 
    args.order = order
94 ashish 1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
483 rajveer 1881 
  def recv_createOrder(self, ):
94 ashish 1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
483 rajveer 1888 
    result = createOrder_result()
94 ashish 1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
94 ashish 1892 
      return result.success
3431 rajveer 1893 
    if result.ex is not None:
94 ashish 1894 
      raise result.ex
483 rajveer 1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1896 
 
483 rajveer 1897 
  def getOrder(self, id):
94 ashish 1898 
    """
1899 
    Parameters:
483 rajveer 1900 
     - id
94 ashish 1901 
    """
483 rajveer 1902 
    self.send_getOrder(id)
1903 
    return self.recv_getOrder()
94 ashish 1904 
 
483 rajveer 1905 
  def send_getOrder(self, id):
1906 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1907 
    args = getOrder_args()
1908 
    args.id = id
94 ashish 1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
483 rajveer 1913 
  def recv_getOrder(self, ):
94 ashish 1914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1915 
    if mtype == TMessageType.EXCEPTION:
1916 
      x = TApplicationException()
1917 
      x.read(self._iprot)
1918 
      self._iprot.readMessageEnd()
1919 
      raise x
483 rajveer 1920 
    result = getOrder_result()
94 ashish 1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
3431 rajveer 1923 
    if result.success is not None:
94 ashish 1924 
      return result.success
3431 rajveer 1925 
    if result.ex is not None:
94 ashish 1926 
      raise result.ex
483 rajveer 1927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1928 
 
483 rajveer 1929 
  def getLineItemsForOrder(self, orderId):
94 ashish 1930 
    """
1931 
    Parameters:
483 rajveer 1932 
     - orderId
94 ashish 1933 
    """
483 rajveer 1934 
    self.send_getLineItemsForOrder(orderId)
1935 
    return self.recv_getLineItemsForOrder()
94 ashish 1936 
 
483 rajveer 1937 
  def send_getLineItemsForOrder(self, orderId):
1938 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1939 
    args = getLineItemsForOrder_args()
1940 
    args.orderId = orderId
94 ashish 1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
483 rajveer 1945 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
483 rajveer 1952 
    result = getLineItemsForOrder_result()
94 ashish 1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
3431 rajveer 1955 
    if result.success is not None:
94 ashish 1956 
      return result.success
3431 rajveer 1957 
    if result.ex is not None:
94 ashish 1958 
      raise result.ex
483 rajveer 1959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1960 
 
4999 phani.kuma 1961 
  def getOrderList(self, order_ids):
1962 
    """
1963 
    Parameters:
1964 
     - order_ids
1965 
    """
1966 
    self.send_getOrderList(order_ids)
1967 
    return self.recv_getOrderList()
1968 
 
1969 
  def send_getOrderList(self, order_ids):
1970 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1971 
    args = getOrderList_args()
1972 
    args.order_ids = order_ids
1973 
    args.write(self._oprot)
1974 
    self._oprot.writeMessageEnd()
1975 
    self._oprot.trans.flush()
1976 
 
1977 
  def recv_getOrderList(self, ):
1978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1979 
    if mtype == TMessageType.EXCEPTION:
1980 
      x = TApplicationException()
1981 
      x.read(self._iprot)
1982 
      self._iprot.readMessageEnd()
1983 
      raise x
1984 
    result = getOrderList_result()
1985 
    result.read(self._iprot)
1986 
    self._iprot.readMessageEnd()
1987 
    if result.success is not None:
1988 
      return result.success
1989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1990 
 
5386 phani.kuma 1991 
  def getOrderListForVendor(self, order_ids, vendorId):
1992 
    """
1993 
    Parameters:
1994 
     - order_ids
1995 
     - vendorId
1996 
    """
1997 
    self.send_getOrderListForVendor(order_ids, vendorId)
1998 
    return self.recv_getOrderListForVendor()
1999 
 
2000 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2001 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2002 
    args = getOrderListForVendor_args()
2003 
    args.order_ids = order_ids
2004 
    args.vendorId = vendorId
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_getOrderListForVendor(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = getOrderListForVendor_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
2019 
    if result.success is not None:
2020 
      return result.success
2021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2022 
 
1528 ankur.sing 2023 
  def getOrderForCustomer(self, orderId, customerId):
2024 
    """
2025 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2026 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2027 
 
1528 ankur.sing 2028 
    Parameters:
2029 
     - orderId
2030 
     - customerId
2031 
    """
2032 
    self.send_getOrderForCustomer(orderId, customerId)
2033 
    return self.recv_getOrderForCustomer()
2034 
 
2035 
  def send_getOrderForCustomer(self, orderId, customerId):
2036 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2037 
    args = getOrderForCustomer_args()
2038 
    args.orderId = orderId
2039 
    args.customerId = customerId
2040 
    args.write(self._oprot)
2041 
    self._oprot.writeMessageEnd()
2042 
    self._oprot.trans.flush()
2043 
 
2044 
  def recv_getOrderForCustomer(self, ):
2045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2046 
    if mtype == TMessageType.EXCEPTION:
2047 
      x = TApplicationException()
2048 
      x.read(self._iprot)
2049 
      self._iprot.readMessageEnd()
2050 
      raise x
2051 
    result = getOrderForCustomer_result()
2052 
    result.read(self._iprot)
2053 
    self._iprot.readMessageEnd()
3431 rajveer 2054 
    if result.success is not None:
1528 ankur.sing 2055 
      return result.success
3431 rajveer 2056 
    if result.ex is not None:
1528 ankur.sing 2057 
      raise result.ex
2058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2059 
 
4444 rajveer 2060 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2061 
    """
2062 
    Parameters:
4394 rajveer 2063 
     - type
4444 rajveer 2064 
     - warehouseId
4394 rajveer 2065 
     - status
2066 
     - timestamp
3064 chandransh 2067 
    """
4444 rajveer 2068 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2069 
    return self.recv_getAlerts()
2070 
 
4444 rajveer 2071 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2072 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2073 
    args = getAlerts_args()
4394 rajveer 2074 
    args.type = type
4444 rajveer 2075 
    args.warehouseId = warehouseId
4394 rajveer 2076 
    args.status = status
2077 
    args.timestamp = timestamp
3064 chandransh 2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
2082 
  def recv_getAlerts(self, ):
2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
2089 
    result = getAlerts_result()
2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
3431 rajveer 2092 
    if result.success is not None:
3064 chandransh 2093 
      return result.success
2094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2095 
 
4444 rajveer 2096 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2097 
    """
2098 
    Parameters:
2099 
     - type
4444 rajveer 2100 
     - warehouseId
4394 rajveer 2101 
     - description
3064 chandransh 2102 
    """
4444 rajveer 2103 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2104 
    self.recv_addAlert()
3064 chandransh 2105 
 
4444 rajveer 2106 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2107 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2108 
    args = addAlert_args()
3064 chandransh 2109 
    args.type = type
4444 rajveer 2110 
    args.warehouseId = warehouseId
4394 rajveer 2111 
    args.description = description
3064 chandransh 2112 
    args.write(self._oprot)
2113 
    self._oprot.writeMessageEnd()
2114 
    self._oprot.trans.flush()
2115 
 
4394 rajveer 2116 
  def recv_addAlert(self, ):
3064 chandransh 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
4394 rajveer 2123 
    result = addAlert_result()
3064 chandransh 2124 
    result.read(self._iprot)
2125 
    self._iprot.readMessageEnd()
2126 
    return
2127 
 
4444 rajveer 2128 
  def markAlertsAsSeen(self, warehouseId):
2129 
    """
2130 
    Parameters:
2131 
     - warehouseId
2132 
    """
2133 
    self.send_markAlertsAsSeen(warehouseId)
2134 
    self.recv_markAlertsAsSeen()
2135 
 
2136 
  def send_markAlertsAsSeen(self, warehouseId):
2137 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2138 
    args = markAlertsAsSeen_args()
2139 
    args.warehouseId = warehouseId
2140 
    args.write(self._oprot)
2141 
    self._oprot.writeMessageEnd()
2142 
    self._oprot.trans.flush()
2143 
 
2144 
  def recv_markAlertsAsSeen(self, ):
2145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2146 
    if mtype == TMessageType.EXCEPTION:
2147 
      x = TApplicationException()
2148 
      x.read(self._iprot)
2149 
      self._iprot.readMessageEnd()
2150 
      raise x
2151 
    result = markAlertsAsSeen_result()
2152 
    result.read(self._iprot)
2153 
    self._iprot.readMessageEnd()
2154 
    return
2155 
 
3064 chandransh 2156 
  def getValidOrderCount(self, ):
2157 
    """
2158 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2159 
    """
2160 
    self.send_getValidOrderCount()
2161 
    return self.recv_getValidOrderCount()
2162 
 
2163 
  def send_getValidOrderCount(self, ):
2164 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2165 
    args = getValidOrderCount_args()
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_getValidOrderCount(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = getValidOrderCount_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
3064 chandransh 2181 
      return result.success
2182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2183 
 
2184 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2185 
    """
2186 
    Returns the number of distinct customers who have done successful transactions
2187 
    """
2188 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2189 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2190 
 
2191 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2192 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2193 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2194 
    args.write(self._oprot)
2195 
    self._oprot.writeMessageEnd()
2196 
    self._oprot.trans.flush()
2197 
 
2198 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2200 
    if mtype == TMessageType.EXCEPTION:
2201 
      x = TApplicationException()
2202 
      x.read(self._iprot)
2203 
      self._iprot.readMessageEnd()
2204 
      raise x
2205 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2206 
    result.read(self._iprot)
2207 
    self._iprot.readMessageEnd()
3431 rajveer 2208 
    if result.success is not None:
3064 chandransh 2209 
      return result.success
2210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2211 
 
2212 
  def getValidOrdersAmountRange(self, ):
2213 
    """
2214 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2215 
    List contains two values, first minimum amount and second maximum amount.
2216 
    """
2217 
    self.send_getValidOrdersAmountRange()
2218 
    return self.recv_getValidOrdersAmountRange()
2219 
 
2220 
  def send_getValidOrdersAmountRange(self, ):
2221 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2222 
    args = getValidOrdersAmountRange_args()
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_getValidOrdersAmountRange(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = getValidOrdersAmountRange_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.success is not None:
3064 chandransh 2238 
      return result.success
2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2240 
 
2241 
  def getValidOrders(self, limit):
2242 
    """
2243 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2244 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2245 
 
3064 chandransh 2246 
    Parameters:
2247 
     - limit
2248 
    """
2249 
    self.send_getValidOrders(limit)
2250 
    return self.recv_getValidOrders()
2251 
 
2252 
  def send_getValidOrders(self, limit):
2253 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2254 
    args = getValidOrders_args()
2255 
    args.limit = limit
2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
2260 
  def recv_getValidOrders(self, ):
2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
2267 
    result = getValidOrders_result()
2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
3064 chandransh 2271 
      return result.success
2272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2273 
 
1220 chandransh 2274 
  def batchOrders(self, warehouseId):
2275 
    """
2276 
    Create a batch of all the pending orders for the given warehouse.
2277 
    The returned list is orderd by created_timestamp.
2278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2279 
 
1220 chandransh 2280 
    Parameters:
2281 
     - warehouseId
2282 
    """
2283 
    self.send_batchOrders(warehouseId)
2284 
    return self.recv_batchOrders()
2285 
 
2286 
  def send_batchOrders(self, warehouseId):
2287 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2288 
    args = batchOrders_args()
2289 
    args.warehouseId = warehouseId
2290 
    args.write(self._oprot)
2291 
    self._oprot.writeMessageEnd()
2292 
    self._oprot.trans.flush()
2293 
 
2294 
  def recv_batchOrders(self, ):
2295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2296 
    if mtype == TMessageType.EXCEPTION:
2297 
      x = TApplicationException()
2298 
      x.read(self._iprot)
2299 
      self._iprot.readMessageEnd()
2300 
      raise x
2301 
    result = batchOrders_result()
2302 
    result.read(self._iprot)
2303 
    self._iprot.readMessageEnd()
3431 rajveer 2304 
    if result.success is not None:
1220 chandransh 2305 
      return result.success
3431 rajveer 2306 
    if result.ex is not None:
1220 chandransh 2307 
      raise result.ex
2308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2309 
 
1208 chandransh 2310 
  def markOrderAsOutOfStock(self, orderId):
2311 
    """
2312 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2313 
 
1208 chandransh 2314 
    Parameters:
2315 
     - orderId
2316 
    """
2317 
    self.send_markOrderAsOutOfStock(orderId)
2318 
    return self.recv_markOrderAsOutOfStock()
2319 
 
2320 
  def send_markOrderAsOutOfStock(self, orderId):
2321 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2322 
    args = markOrderAsOutOfStock_args()
2323 
    args.orderId = orderId
2324 
    args.write(self._oprot)
2325 
    self._oprot.writeMessageEnd()
2326 
    self._oprot.trans.flush()
2327 
 
2328 
  def recv_markOrderAsOutOfStock(self, ):
2329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2330 
    if mtype == TMessageType.EXCEPTION:
2331 
      x = TApplicationException()
2332 
      x.read(self._iprot)
2333 
      self._iprot.readMessageEnd()
2334 
      raise x
2335 
    result = markOrderAsOutOfStock_result()
2336 
    result.read(self._iprot)
2337 
    self._iprot.readMessageEnd()
3431 rajveer 2338 
    if result.success is not None:
1208 chandransh 2339 
      return result.success
3431 rajveer 2340 
    if result.ex is not None:
1208 chandransh 2341 
      raise result.ex
2342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2343 
 
3064 chandransh 2344 
  def verifyOrder(self, orderId):
759 chandransh 2345 
    """
3064 chandransh 2346 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2347 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2348 
    used for all other orders as well.
2349 
    Throws an exception if no such order exists.
3431 rajveer 2350 
 
759 chandransh 2351 
    Parameters:
3064 chandransh 2352 
     - orderId
759 chandransh 2353 
    """
3064 chandransh 2354 
    self.send_verifyOrder(orderId)
2355 
    return self.recv_verifyOrder()
759 chandransh 2356 
 
3064 chandransh 2357 
  def send_verifyOrder(self, orderId):
2358 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2359 
    args = verifyOrder_args()
2360 
    args.orderId = orderId
759 chandransh 2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
3064 chandransh 2365 
  def recv_verifyOrder(self, ):
759 chandransh 2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
3064 chandransh 2372 
    result = verifyOrder_result()
759 chandransh 2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
3431 rajveer 2375 
    if result.success is not None:
759 chandransh 2376 
      return result.success
3431 rajveer 2377 
    if result.ex is not None:
759 chandransh 2378 
      raise result.ex
3064 chandransh 2379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2380 
 
3064 chandransh 2381 
  def acceptOrder(self, orderId):
1113 chandransh 2382 
    """
3064 chandransh 2383 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2384 
    given order is not a COD order, it also captures the payment if the same has
2385 
    not been captured.
2386 
    Throws an exception if no such order exists.
3431 rajveer 2387 
 
1113 chandransh 2388 
    Parameters:
3064 chandransh 2389 
     - orderId
1113 chandransh 2390 
    """
3064 chandransh 2391 
    self.send_acceptOrder(orderId)
2392 
    return self.recv_acceptOrder()
1113 chandransh 2393 
 
3064 chandransh 2394 
  def send_acceptOrder(self, orderId):
2395 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2396 
    args = acceptOrder_args()
2397 
    args.orderId = orderId
1113 chandransh 2398 
    args.write(self._oprot)
2399 
    self._oprot.writeMessageEnd()
2400 
    self._oprot.trans.flush()
2401 
 
3064 chandransh 2402 
  def recv_acceptOrder(self, ):
1113 chandransh 2403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2404 
    if mtype == TMessageType.EXCEPTION:
2405 
      x = TApplicationException()
2406 
      x.read(self._iprot)
2407 
      self._iprot.readMessageEnd()
2408 
      raise x
3064 chandransh 2409 
    result = acceptOrder_result()
1113 chandransh 2410 
    result.read(self._iprot)
2411 
    self._iprot.readMessageEnd()
3431 rajveer 2412 
    if result.success is not None:
1113 chandransh 2413 
      return result.success
3431 rajveer 2414 
    if result.ex is not None:
1113 chandransh 2415 
      raise result.ex
3064 chandransh 2416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2417 
 
5110 mandeep.dh 2418 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2419 
    """
3064 chandransh 2420 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2421 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2422 
    the IMEI no. if a -1 is supplied.
2423 
    Also, it generates an invoice number for the order, marks the order as
2424 
    BILLED and sets the billing timestamp.
2425 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2426 
 
1135 chandransh 2427 
    Parameters:
3064 chandransh 2428 
     - orderId
2429 
     - invoice_number
4658 mandeep.dh 2430 
     - serialNumber
4283 anupam.sin 2431 
     - itemNumber
3064 chandransh 2432 
     - billed_by
4264 rajveer 2433 
     - jacketNumber
4283 anupam.sin 2434 
     - billingType
5110 mandeep.dh 2435 
     - fulfilmentWarehouseId
4763 rajveer 2436 
     - authorize
1135 chandransh 2437 
    """
5110 mandeep.dh 2438 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2439 
    return self.recv_addBillingDetails()
1135 chandransh 2440 
 
5110 mandeep.dh 2441 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2442 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2443 
    args = addBillingDetails_args()
2444 
    args.orderId = orderId
2445 
    args.invoice_number = invoice_number
4658 mandeep.dh 2446 
    args.serialNumber = serialNumber
4283 anupam.sin 2447 
    args.itemNumber = itemNumber
3064 chandransh 2448 
    args.billed_by = billed_by
4264 rajveer 2449 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2450 
    args.billingType = billingType
5110 mandeep.dh 2451 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2452 
    args.authorize = authorize
1135 chandransh 2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
3064 chandransh 2457 
  def recv_addBillingDetails(self, ):
1135 chandransh 2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
3064 chandransh 2464 
    result = addBillingDetails_result()
1135 chandransh 2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
3431 rajveer 2467 
    if result.success is not None:
3064 chandransh 2468 
      return result.success
3431 rajveer 2469 
    if result.ex is not None:
1135 chandransh 2470 
      raise result.ex
3064 chandransh 2471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2472 
 
4763 rajveer 2473 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2474 
    """
2475 
    Add the invoice number to the order.
2476 
 
2477 
    Parameters:
2478 
     - orderId
2479 
     - invoiceNumber
4763 rajveer 2480 
     - color
4579 rajveer 2481 
    """
4763 rajveer 2482 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2483 
    self.recv_addInvoiceNumber()
2484 
 
4763 rajveer 2485 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2486 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2487 
    args = addInvoiceNumber_args()
2488 
    args.orderId = orderId
2489 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2490 
    args.color = color
4579 rajveer 2491 
    args.write(self._oprot)
2492 
    self._oprot.writeMessageEnd()
2493 
    self._oprot.trans.flush()
2494 
 
2495 
  def recv_addInvoiceNumber(self, ):
2496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2497 
    if mtype == TMessageType.EXCEPTION:
2498 
      x = TApplicationException()
2499 
      x.read(self._iprot)
2500 
      self._iprot.readMessageEnd()
2501 
      raise x
2502 
    result = addInvoiceNumber_result()
2503 
    result.read(self._iprot)
2504 
    self._iprot.readMessageEnd()
2505 
    if result.ex is not None:
2506 
      raise result.ex
2507 
    return
2508 
 
4910 phani.kuma 2509 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2510 
    """
3064 chandransh 2511 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2512 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2513 
 
1408 ankur.sing 2514 
    Parameters:
3064 chandransh 2515 
     - warehouseId
1408 ankur.sing 2516 
     - providerId
3064 chandransh 2517 
     - cod
4910 phani.kuma 2518 
     - orderIds
1408 ankur.sing 2519 
    """
4910 phani.kuma 2520 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2521 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2522 
 
4910 phani.kuma 2523 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2524 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2525 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2526 
    args.warehouseId = warehouseId
1408 ankur.sing 2527 
    args.providerId = providerId
3064 chandransh 2528 
    args.cod = cod
4910 phani.kuma 2529 
    args.orderIds = orderIds
1408 ankur.sing 2530 
    args.write(self._oprot)
2531 
    self._oprot.writeMessageEnd()
2532 
    self._oprot.trans.flush()
2533 
 
4910 phani.kuma 2534 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2536 
    if mtype == TMessageType.EXCEPTION:
2537 
      x = TApplicationException()
2538 
      x.read(self._iprot)
2539 
      self._iprot.readMessageEnd()
2540 
      raise x
4910 phani.kuma 2541 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2542 
    result.read(self._iprot)
2543 
    self._iprot.readMessageEnd()
3431 rajveer 2544 
    if result.success is not None:
1408 ankur.sing 2545 
      return result.success
3431 rajveer 2546 
    if result.ex is not None:
3064 chandransh 2547 
      raise result.ex
4910 phani.kuma 2548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2549 
 
4910 phani.kuma 2550 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2551 
    """
4910 phani.kuma 2552 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2553 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2554 
 
2555 
    Parameters:
2556 
     - providerId
4910 phani.kuma 2557 
     - pickupDetails
4410 rajveer 2558 
    """
4910 phani.kuma 2559 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2560 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2561 
 
4910 phani.kuma 2562 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2563 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2564 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2565 
    args.providerId = providerId
4910 phani.kuma 2566 
    args.pickupDetails = pickupDetails
4410 rajveer 2567 
    args.write(self._oprot)
2568 
    self._oprot.writeMessageEnd()
2569 
    self._oprot.trans.flush()
2570 
 
4910 phani.kuma 2571 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2573 
    if mtype == TMessageType.EXCEPTION:
2574 
      x = TApplicationException()
2575 
      x.read(self._iprot)
2576 
      self._iprot.readMessageEnd()
2577 
      raise x
4910 phani.kuma 2578 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2579 
    result.read(self._iprot)
2580 
    self._iprot.readMessageEnd()
2581 
    if result.ex is not None:
2582 
      raise result.ex
4910 phani.kuma 2583 
    return
4410 rajveer 2584 
 
4910 phani.kuma 2585 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2586 
    """
3064 chandransh 2587 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2588 
 
94 ashish 2589 
    Parameters:
3064 chandransh 2590 
     - providerId
304 ashish 2591 
    """
4910 phani.kuma 2592 
    self.send_getOrdersNotPickedUp(providerId)
2593 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2594 
 
4910 phani.kuma 2595 
  def send_getOrdersNotPickedUp(self, providerId):
2596 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2597 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2598 
    args.providerId = providerId
304 ashish 2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
4910 phani.kuma 2603 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
4910 phani.kuma 2610 
    result = getOrdersNotPickedUp_result()
304 ashish 2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.success is not None:
304 ashish 2614 
      return result.success
4910 phani.kuma 2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2616 
 
3064 chandransh 2617 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2618 
    """
3064 chandransh 2619 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2620 
    the name of the receiver.
2621 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2622 
 
304 ashish 2623 
    Parameters:
3064 chandransh 2624 
     - providerId
2625 
     - deliveredOrders
304 ashish 2626 
    """
3064 chandransh 2627 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2628 
    self.recv_markOrdersAsDelivered()
304 ashish 2629 
 
3064 chandransh 2630 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2631 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2632 
    args = markOrdersAsDelivered_args()
2633 
    args.providerId = providerId
2634 
    args.deliveredOrders = deliveredOrders
304 ashish 2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
3064 chandransh 2639 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
3064 chandransh 2646 
    result = markOrdersAsDelivered_result()
304 ashish 2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.ex is not None:
3064 chandransh 2650 
      raise result.ex
304 ashish 2651 
    return
2652 
 
4910 phani.kuma 2653 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2654 
    """
4910 phani.kuma 2655 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2656 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2657 
 
3064 chandransh 2658 
    Parameters:
2659 
     - providerId
2660 
     - returnedOrders
1596 ankur.sing 2661 
    """
4910 phani.kuma 2662 
    self.send_markAsRTOrders(providerId, returnedOrders)
2663 
    self.recv_markAsRTOrders()
304 ashish 2664 
 
4910 phani.kuma 2665 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2666 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2667 
    args = markAsRTOrders_args()
3064 chandransh 2668 
    args.providerId = providerId
2669 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2670 
    args.write(self._oprot)
2671 
    self._oprot.writeMessageEnd()
2672 
    self._oprot.trans.flush()
2673 
 
4910 phani.kuma 2674 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2676 
    if mtype == TMessageType.EXCEPTION:
2677 
      x = TApplicationException()
2678 
      x.read(self._iprot)
2679 
      self._iprot.readMessageEnd()
2680 
      raise x
4910 phani.kuma 2681 
    result = markAsRTOrders_result()
1596 ankur.sing 2682 
    result.read(self._iprot)
2683 
    self._iprot.readMessageEnd()
3431 rajveer 2684 
    if result.ex is not None:
3064 chandransh 2685 
      raise result.ex
2686 
    return
1596 ankur.sing 2687 
 
4910 phani.kuma 2688 
  def getRTOrders(self, providerId):
2689 
    """
2690 
    Returns a list of orders that were returned by courier.
2691 
 
2692 
    Parameters:
2693 
     - providerId
2694 
    """
2695 
    self.send_getRTOrders(providerId)
2696 
    return self.recv_getRTOrders()
2697 
 
2698 
  def send_getRTOrders(self, providerId):
2699 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2700 
    args = getRTOrders_args()
2701 
    args.providerId = providerId
2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2706 
  def recv_getRTOrders(self, ):
2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2713 
    result = getRTOrders_result()
2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
2716 
    if result.success is not None:
2717 
      return result.success
2718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2719 
 
3064 chandransh 2720 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2721 
    """
3064 chandransh 2722 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2723 
 
3064 chandransh 2724 
    Parameters:
2725 
     - providerId
2726 
     - undeliveredOrders
1627 ankur.sing 2727 
    """
3064 chandransh 2728 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2729 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2730 
 
3064 chandransh 2731 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2732 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2733 
    args = updateNonDeliveryReason_args()
2734 
    args.providerId = providerId
2735 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
3064 chandransh 2740 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
3064 chandransh 2747 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
4910 phani.kuma 2750 
    if result.ex is not None:
2751 
      raise result.ex
2752 
    return
2753 
 
2754 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2755 
    """
2756 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2757 
 
2758 
    Parameters:
2759 
     - providerId
2760 
    """
2761 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2762 
    return self.recv_getNonDeliveredOrdersbyCourier()
2763 
 
2764 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2765 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2766 
    args = getNonDeliveredOrdersbyCourier_args()
2767 
    args.providerId = providerId
2768 
    args.write(self._oprot)
2769 
    self._oprot.writeMessageEnd()
2770 
    self._oprot.trans.flush()
2771 
 
2772 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2774 
    if mtype == TMessageType.EXCEPTION:
2775 
      x = TApplicationException()
2776 
      x.read(self._iprot)
2777 
      self._iprot.readMessageEnd()
2778 
      raise x
2779 
    result = getNonDeliveredOrdersbyCourier_result()
2780 
    result.read(self._iprot)
2781 
    self._iprot.readMessageEnd()
4581 phani.kuma 2782 
    if result.success is not None:
2783 
      return result.success
4910 phani.kuma 2784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2785 
 
2786 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2787 
    """
2788 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2789 
 
2790 
    Parameters:
2791 
     - providerId
2792 
     - local_connected_orders
2793 
    """
2794 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2795 
    self.recv_markOrdersAsLocalConnected()
2796 
 
2797 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2798 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2799 
    args = markOrdersAsLocalConnected_args()
2800 
    args.providerId = providerId
2801 
    args.local_connected_orders = local_connected_orders
2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2806 
  def recv_markOrdersAsLocalConnected(self, ):
2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2813 
    result = markOrdersAsLocalConnected_result()
2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
3431 rajveer 2816 
    if result.ex is not None:
3064 chandransh 2817 
      raise result.ex
4910 phani.kuma 2818 
    return
1627 ankur.sing 2819 
 
4910 phani.kuma 2820 
  def getOrdersNotLocalConnected(self, providerId):
2821 
    """
2822 
    Returns a list of orders that were picked up or shipped but pending local connection.
2823 
 
2824 
    Parameters:
2825 
     - providerId
2826 
    """
2827 
    self.send_getOrdersNotLocalConnected(providerId)
2828 
    return self.recv_getOrdersNotLocalConnected()
2829 
 
2830 
  def send_getOrdersNotLocalConnected(self, providerId):
2831 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2832 
    args = getOrdersNotLocalConnected_args()
2833 
    args.providerId = providerId
2834 
    args.write(self._oprot)
2835 
    self._oprot.writeMessageEnd()
2836 
    self._oprot.trans.flush()
2837 
 
2838 
  def recv_getOrdersNotLocalConnected(self, ):
2839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2840 
    if mtype == TMessageType.EXCEPTION:
2841 
      x = TApplicationException()
2842 
      x.read(self._iprot)
2843 
      self._iprot.readMessageEnd()
2844 
      raise x
2845 
    result = getOrdersNotLocalConnected_result()
2846 
    result.read(self._iprot)
2847 
    self._iprot.readMessageEnd()
2848 
    if result.success is not None:
2849 
      return result.success
2850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2851 
 
2852 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2853 
    """
2854 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2855 
 
2856 
    Parameters:
2857 
     - providerId
2858 
     - destination_city_reached_orders
2859 
    """
2860 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2861 
    self.recv_markOrdersAsDestinationCityReached()
2862 
 
2863 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2864 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2865 
    args = markOrdersAsDestinationCityReached_args()
2866 
    args.providerId = providerId
2867 
    args.destination_city_reached_orders = destination_city_reached_orders
2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
2872 
  def recv_markOrdersAsDestinationCityReached(self, ):
2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
2879 
    result = markOrdersAsDestinationCityReached_result()
2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
2882 
    if result.ex is not None:
2883 
      raise result.ex
2884 
    return
2885 
 
2886 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2887 
    """
2888 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2889 
 
2890 
    Parameters:
2891 
     - providerId
2892 
     - first_atdl_orders
2893 
    """
2894 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2895 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2896 
 
2897 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2898 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2899 
    args = markOrdersAsFirstDeliveryAttempted_args()
2900 
    args.providerId = providerId
2901 
    args.first_atdl_orders = first_atdl_orders
2902 
    args.write(self._oprot)
2903 
    self._oprot.writeMessageEnd()
2904 
    self._oprot.trans.flush()
2905 
 
2906 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2908 
    if mtype == TMessageType.EXCEPTION:
2909 
      x = TApplicationException()
2910 
      x.read(self._iprot)
2911 
      self._iprot.readMessageEnd()
2912 
      raise x
2913 
    result = markOrdersAsFirstDeliveryAttempted_result()
2914 
    result.read(self._iprot)
2915 
    self._iprot.readMessageEnd()
2916 
    if result.ex is not None:
2917 
      raise result.ex
2918 
    return
2919 
 
3064 chandransh 2920 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2921 
    """
3064 chandransh 2922 
    Returns the list of orders whose delivery time has passed but have not been
2923 
    delivered yet for the given provider and warehouse. To get a complete list of
2924 
    undelivered orders, pass them as -1.
2925 
    Returns an empty list if no such orders exist.
3431 rajveer 2926 
 
1886 ankur.sing 2927 
    Parameters:
3064 chandransh 2928 
     - providerId
2929 
     - warehouseId
1886 ankur.sing 2930 
    """
3064 chandransh 2931 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2932 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2933 
 
3064 chandransh 2934 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2935 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2936 
    args = getUndeliveredOrders_args()
2937 
    args.providerId = providerId
2938 
    args.warehouseId = warehouseId
1886 ankur.sing 2939 
    args.write(self._oprot)
2940 
    self._oprot.writeMessageEnd()
2941 
    self._oprot.trans.flush()
2942 
 
3064 chandransh 2943 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2945 
    if mtype == TMessageType.EXCEPTION:
2946 
      x = TApplicationException()
2947 
      x.read(self._iprot)
2948 
      self._iprot.readMessageEnd()
2949 
      raise x
3064 chandransh 2950 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2951 
    result.read(self._iprot)
2952 
    self._iprot.readMessageEnd()
3431 rajveer 2953 
    if result.success is not None:
1886 ankur.sing 2954 
      return result.success
3064 chandransh 2955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2956 
 
4783 phani.kuma 2957 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2958 
    """
2959 
    Returns the list of orders whose expected delivery date has passed but have not been
2960 
    delivered yet.
2961 
    Returns an empty list if no such orders exist.
2962 
    """
2963 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2964 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2965 
 
2966 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2967 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2968 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2969 
    args.write(self._oprot)
2970 
    self._oprot.writeMessageEnd()
2971 
    self._oprot.trans.flush()
2972 
 
2973 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2975 
    if mtype == TMessageType.EXCEPTION:
2976 
      x = TApplicationException()
2977 
      x.read(self._iprot)
2978 
      self._iprot.readMessageEnd()
2979 
      raise x
2980 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2981 
    result.read(self._iprot)
2982 
    self._iprot.readMessageEnd()
2983 
    if result.success is not None:
2984 
      return result.success
2985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2986 
 
2536 chandransh 2987 
  def toggleDOAFlag(self, orderId):
2988 
    """
2989 
    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.
2990 
    Returns the final flag status.
2991 
    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 2992 
 
2536 chandransh 2993 
    Parameters:
2994 
     - orderId
2995 
    """
2996 
    self.send_toggleDOAFlag(orderId)
2997 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2998 
 
2536 chandransh 2999 
  def send_toggleDOAFlag(self, orderId):
3000 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3001 
    args = toggleDOAFlag_args()
3002 
    args.orderId = orderId
3003 
    args.write(self._oprot)
3004 
    self._oprot.writeMessageEnd()
3005 
    self._oprot.trans.flush()
3006 
 
3007 
  def recv_toggleDOAFlag(self, ):
3008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3009 
    if mtype == TMessageType.EXCEPTION:
3010 
      x = TApplicationException()
3011 
      x.read(self._iprot)
3012 
      self._iprot.readMessageEnd()
3013 
      raise x
3014 
    result = toggleDOAFlag_result()
3015 
    result.read(self._iprot)
3016 
    self._iprot.readMessageEnd()
3431 rajveer 3017 
    if result.success is not None:
2536 chandransh 3018 
      return result.success
3431 rajveer 3019 
    if result.ex is not None:
2536 chandransh 3020 
      raise result.ex
3021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3022 
 
4712 rajveer 3023 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3024 
    """
3025 
    Parameters:
3026 
     - orderId
3027 
     - deliveryTimestamp
3028 
     - receiver
3029 
    """
3030 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3031 
    self.recv_markOrderAsDelivered()
3032 
 
3033 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3034 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3035 
    args = markOrderAsDelivered_args()
3036 
    args.orderId = orderId
3037 
    args.deliveryTimestamp = deliveryTimestamp
3038 
    args.receiver = receiver
3039 
    args.write(self._oprot)
3040 
    self._oprot.writeMessageEnd()
3041 
    self._oprot.trans.flush()
3042 
 
3043 
  def recv_markOrderAsDelivered(self, ):
3044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3045 
    if mtype == TMessageType.EXCEPTION:
3046 
      x = TApplicationException()
3047 
      x.read(self._iprot)
3048 
      self._iprot.readMessageEnd()
3049 
      raise x
3050 
    result = markOrderAsDelivered_result()
3051 
    result.read(self._iprot)
3052 
    self._iprot.readMessageEnd()
3053 
    if result.ex is not None:
3054 
      raise result.ex
3055 
    return
3056 
 
5553 rajveer 3057 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3058 
    """
3059 
    Parameters:
3060 
     - orderId
3061 
     - deliveryTimestamp
3062 
    """
3063 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3064 
    self.recv_markOrderAsReceivedAtStore()
3065 
 
3066 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3067 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3068 
    args = markOrderAsReceivedAtStore_args()
3069 
    args.orderId = orderId
3070 
    args.deliveryTimestamp = deliveryTimestamp
3071 
    args.write(self._oprot)
3072 
    self._oprot.writeMessageEnd()
3073 
    self._oprot.trans.flush()
3074 
 
3075 
  def recv_markOrderAsReceivedAtStore(self, ):
3076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3077 
    if mtype == TMessageType.EXCEPTION:
3078 
      x = TApplicationException()
3079 
      x.read(self._iprot)
3080 
      self._iprot.readMessageEnd()
3081 
      raise x
3082 
    result = markOrderAsReceivedAtStore_result()
3083 
    result.read(self._iprot)
3084 
    self._iprot.readMessageEnd()
3085 
    if result.ex is not None:
3086 
      raise result.ex
3087 
    return
3088 
 
4454 rajveer 3089 
  def markOrderDoaRequestReceived(self, orderId):
3090 
    """
3091 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3092 
 
3093 
    Parameters:
3094 
     - orderId
3095 
    """
3096 
    self.send_markOrderDoaRequestReceived(orderId)
3097 
    return self.recv_markOrderDoaRequestReceived()
3098 
 
3099 
  def send_markOrderDoaRequestReceived(self, orderId):
3100 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3101 
    args = markOrderDoaRequestReceived_args()
3102 
    args.orderId = orderId
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_markOrderDoaRequestReceived(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = markOrderDoaRequestReceived_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    if result.ex is not None:
3120 
      raise result.ex
3121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3122 
 
3123 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3124 
    """
3125 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3126 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3127 
 
3128 
    Parameters:
3129 
     - orderId
3130 
     - isAuthorized
3131 
    """
3132 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3133 
    return self.recv_markOrderDoaRequestAuthorized()
3134 
 
3135 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3136 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3137 
    args = markOrderDoaRequestAuthorized_args()
3138 
    args.orderId = orderId
3139 
    args.isAuthorized = isAuthorized
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_markOrderDoaRequestAuthorized(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = markOrderDoaRequestAuthorized_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3154 
    if result.success is not None:
3155 
      return result.success
3156 
    if result.ex is not None:
3157 
      raise result.ex
3158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3159 
 
4488 rajveer 3160 
  def markOrderReturnRequestReceived(self, orderId):
3161 
    """
3162 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3163 
 
3164 
    Parameters:
3165 
     - orderId
3166 
    """
3167 
    self.send_markOrderReturnRequestReceived(orderId)
3168 
    return self.recv_markOrderReturnRequestReceived()
3169 
 
3170 
  def send_markOrderReturnRequestReceived(self, orderId):
3171 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3172 
    args = markOrderReturnRequestReceived_args()
3173 
    args.orderId = orderId
3174 
    args.write(self._oprot)
3175 
    self._oprot.writeMessageEnd()
3176 
    self._oprot.trans.flush()
3177 
 
3178 
  def recv_markOrderReturnRequestReceived(self, ):
3179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3180 
    if mtype == TMessageType.EXCEPTION:
3181 
      x = TApplicationException()
3182 
      x.read(self._iprot)
3183 
      self._iprot.readMessageEnd()
3184 
      raise x
3185 
    result = markOrderReturnRequestReceived_result()
3186 
    result.read(self._iprot)
3187 
    self._iprot.readMessageEnd()
3188 
    if result.success is not None:
3189 
      return result.success
3190 
    if result.ex is not None:
3191 
      raise result.ex
3192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3193 
 
3194 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3195 
    """
3196 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3197 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3198 
 
3199 
    Parameters:
3200 
     - orderId
3201 
     - isAuthorized
3202 
    """
3203 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3204 
    return self.recv_markOrderReturnRequestAuthorized()
3205 
 
3206 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3207 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3208 
    args = markOrderReturnRequestAuthorized_args()
3209 
    args.orderId = orderId
3210 
    args.isAuthorized = isAuthorized
3211 
    args.write(self._oprot)
3212 
    self._oprot.writeMessageEnd()
3213 
    self._oprot.trans.flush()
3214 
 
3215 
  def recv_markOrderReturnRequestAuthorized(self, ):
3216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3217 
    if mtype == TMessageType.EXCEPTION:
3218 
      x = TApplicationException()
3219 
      x.read(self._iprot)
3220 
      self._iprot.readMessageEnd()
3221 
      raise x
3222 
    result = markOrderReturnRequestAuthorized_result()
3223 
    result.read(self._iprot)
3224 
    self._iprot.readMessageEnd()
3225 
    if result.success is not None:
3226 
      return result.success
3227 
    if result.ex is not None:
3228 
      raise result.ex
3229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3230 
 
4579 rajveer 3231 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3232 
    """
3233 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3234 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3235 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3236 
    For any other status, it returns false.
3237 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3238 
 
2536 chandransh 3239 
    Parameters:
3240 
     - orderId
4579 rajveer 3241 
     - providerId
2536 chandransh 3242 
    """
4579 rajveer 3243 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3244 
    return self.recv_requestPickupNumber()
3245 
 
4579 rajveer 3246 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3247 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3248 
    args = requestPickupNumber_args()
3249 
    args.orderId = orderId
4579 rajveer 3250 
    args.providerId = providerId
2536 chandransh 3251 
    args.write(self._oprot)
3252 
    self._oprot.writeMessageEnd()
3253 
    self._oprot.trans.flush()
3254 
 
3255 
  def recv_requestPickupNumber(self, ):
3256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3257 
    if mtype == TMessageType.EXCEPTION:
3258 
      x = TApplicationException()
3259 
      x.read(self._iprot)
3260 
      self._iprot.readMessageEnd()
3261 
      raise x
3262 
    result = requestPickupNumber_result()
3263 
    result.read(self._iprot)
3264 
    self._iprot.readMessageEnd()
3431 rajveer 3265 
    if result.success is not None:
2536 chandransh 3266 
      return result.success
3431 rajveer 3267 
    if result.ex is not None:
2536 chandransh 3268 
      raise result.ex
3269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3270 
 
4602 rajveer 3271 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3272 
    """
4452 rajveer 3273 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3274 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3275 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3276 
    	3. Returns true
2591 chandransh 3277 
    If the order is in any other status, it returns false.
2536 chandransh 3278 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3279 
 
2536 chandransh 3280 
    Parameters:
3281 
     - orderId
3282 
     - pickupNumber
4602 rajveer 3283 
     - providerId
2536 chandransh 3284 
    """
4602 rajveer 3285 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3286 
    return self.recv_authorizePickup()
3287 
 
4602 rajveer 3288 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3289 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3290 
    args = authorizePickup_args()
3291 
    args.orderId = orderId
3292 
    args.pickupNumber = pickupNumber
4602 rajveer 3293 
    args.providerId = providerId
2536 chandransh 3294 
    args.write(self._oprot)
3295 
    self._oprot.writeMessageEnd()
3296 
    self._oprot.trans.flush()
3297 
 
3298 
  def recv_authorizePickup(self, ):
3299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3300 
    if mtype == TMessageType.EXCEPTION:
3301 
      x = TApplicationException()
3302 
      x.read(self._iprot)
3303 
      self._iprot.readMessageEnd()
3304 
      raise x
3305 
    result = authorizePickup_result()
3306 
    result.read(self._iprot)
3307 
    self._iprot.readMessageEnd()
3431 rajveer 3308 
    if result.success is not None:
2536 chandransh 3309 
      return result.success
3431 rajveer 3310 
    if result.ex is not None:
2536 chandransh 3311 
      raise result.ex
3312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3313 
 
2764 chandransh 3314 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3315 
    """
3316 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3317 
 
2764 chandransh 3318 
    Parameters:
3319 
     - providerId
3320 
     - pickupDetails
3321 
    """
3322 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3323 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3324 
 
3325 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3326 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3327 
    args = markDoasAsPickedUp_args()
3328 
    args.providerId = providerId
3329 
    args.pickupDetails = pickupDetails
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_markDoasAsPickedUp(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = markDoasAsPickedUp_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
4910 phani.kuma 3344 
    return
3345 
 
3346 
  def getDoasNotPickedUp(self, providerId):
3347 
    """
3348 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3349 
 
3350 
    Parameters:
3351 
     - providerId
3352 
    """
3353 
    self.send_getDoasNotPickedUp(providerId)
3354 
    return self.recv_getDoasNotPickedUp()
3355 
 
3356 
  def send_getDoasNotPickedUp(self, providerId):
3357 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3358 
    args = getDoasNotPickedUp_args()
3359 
    args.providerId = providerId
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_getDoasNotPickedUp(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = getDoasNotPickedUp_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3431 rajveer 3374 
    if result.success is not None:
2764 chandransh 3375 
      return result.success
4910 phani.kuma 3376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3377 
 
4741 phani.kuma 3378 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3379 
    """
3380 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3381 
 
3382 
    Parameters:
3383 
     - providerId
3384 
     - pickupDetails
3385 
    """
3386 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3387 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3388 
 
3389 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3390 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3391 
    args = markReturnOrdersAsPickedUp_args()
3392 
    args.providerId = providerId
3393 
    args.pickupDetails = pickupDetails
3394 
    args.write(self._oprot)
3395 
    self._oprot.writeMessageEnd()
3396 
    self._oprot.trans.flush()
3397 
 
3398 
  def recv_markReturnOrdersAsPickedUp(self, ):
3399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3400 
    if mtype == TMessageType.EXCEPTION:
3401 
      x = TApplicationException()
3402 
      x.read(self._iprot)
3403 
      self._iprot.readMessageEnd()
3404 
      raise x
3405 
    result = markReturnOrdersAsPickedUp_result()
3406 
    result.read(self._iprot)
3407 
    self._iprot.readMessageEnd()
4910 phani.kuma 3408 
    return
3409 
 
3410 
  def getReturnOrdersNotPickedUp(self, providerId):
3411 
    """
3412 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3413 
 
3414 
    Parameters:
3415 
     - providerId
3416 
    """
3417 
    self.send_getReturnOrdersNotPickedUp(providerId)
3418 
    return self.recv_getReturnOrdersNotPickedUp()
3419 
 
3420 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3421 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3422 
    args = getReturnOrdersNotPickedUp_args()
3423 
    args.providerId = providerId
3424 
    args.write(self._oprot)
3425 
    self._oprot.writeMessageEnd()
3426 
    self._oprot.trans.flush()
3427 
 
3428 
  def recv_getReturnOrdersNotPickedUp(self, ):
3429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3430 
    if mtype == TMessageType.EXCEPTION:
3431 
      x = TApplicationException()
3432 
      x.read(self._iprot)
3433 
      self._iprot.readMessageEnd()
3434 
      raise x
3435 
    result = getReturnOrdersNotPickedUp_result()
3436 
    result.read(self._iprot)
3437 
    self._iprot.readMessageEnd()
4741 phani.kuma 3438 
    if result.success is not None:
3439 
      return result.success
4910 phani.kuma 3440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3441 
 
4479 rajveer 3442 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3443 
    """
4452 rajveer 3444 
    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 3445 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3446 
    If the order is in any other state, it returns false.
3447 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3448 
 
2591 chandransh 3449 
    Parameters:
3450 
     - orderId
4479 rajveer 3451 
     - receiveCondition
2591 chandransh 3452 
    """
4479 rajveer 3453 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3454 
    return self.recv_receiveReturn()
2536 chandransh 3455 
 
4479 rajveer 3456 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3457 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3458 
    args = receiveReturn_args()
2591 chandransh 3459 
    args.orderId = orderId
4479 rajveer 3460 
    args.receiveCondition = receiveCondition
2591 chandransh 3461 
    args.write(self._oprot)
3462 
    self._oprot.writeMessageEnd()
3463 
    self._oprot.trans.flush()
3464 
 
2616 chandransh 3465 
  def recv_receiveReturn(self, ):
2591 chandransh 3466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3467 
    if mtype == TMessageType.EXCEPTION:
3468 
      x = TApplicationException()
3469 
      x.read(self._iprot)
3470 
      self._iprot.readMessageEnd()
3471 
      raise x
2616 chandransh 3472 
    result = receiveReturn_result()
2591 chandransh 3473 
    result.read(self._iprot)
3474 
    self._iprot.readMessageEnd()
3431 rajveer 3475 
    if result.success is not None:
2591 chandransh 3476 
      return result.success
3431 rajveer 3477 
    if result.ex is not None:
2591 chandransh 3478 
      raise result.ex
2616 chandransh 3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3480 
 
3481 
  def validateDoa(self, orderId, isValid):
3482 
    """
4452 rajveer 3483 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3484 
    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 3485 
    If the order is in any other state, it returns false.
3486 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3487 
 
2591 chandransh 3488 
    Parameters:
3489 
     - orderId
3490 
     - isValid
3491 
    """
3492 
    self.send_validateDoa(orderId, isValid)
3493 
    return self.recv_validateDoa()
3494 
 
3495 
  def send_validateDoa(self, orderId, isValid):
3496 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3497 
    args = validateDoa_args()
3498 
    args.orderId = orderId
3499 
    args.isValid = isValid
3500 
    args.write(self._oprot)
3501 
    self._oprot.writeMessageEnd()
3502 
    self._oprot.trans.flush()
3503 
 
3504 
  def recv_validateDoa(self, ):
3505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3506 
    if mtype == TMessageType.EXCEPTION:
3507 
      x = TApplicationException()
3508 
      x.read(self._iprot)
3509 
      self._iprot.readMessageEnd()
3510 
      raise x
3511 
    result = validateDoa_result()
3512 
    result.read(self._iprot)
3513 
    self._iprot.readMessageEnd()
3431 rajveer 3514 
    if result.success is not None:
2591 chandransh 3515 
      return result.success
3431 rajveer 3516 
    if result.ex is not None:
2591 chandransh 3517 
      raise result.ex
3518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3519 
 
4495 rajveer 3520 
  def validateReturnProduct(self, orderId, isUsable):
3521 
    """
3522 
    Parameters:
3523 
     - orderId
3524 
     - isUsable
3525 
    """
3526 
    self.send_validateReturnProduct(orderId, isUsable)
3527 
    return self.recv_validateReturnProduct()
3528 
 
3529 
  def send_validateReturnProduct(self, orderId, isUsable):
3530 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3531 
    args = validateReturnProduct_args()
3532 
    args.orderId = orderId
3533 
    args.isUsable = isUsable
3534 
    args.write(self._oprot)
3535 
    self._oprot.writeMessageEnd()
3536 
    self._oprot.trans.flush()
3537 
 
3538 
  def recv_validateReturnProduct(self, ):
3539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3540 
    if mtype == TMessageType.EXCEPTION:
3541 
      x = TApplicationException()
3542 
      x.read(self._iprot)
3543 
      self._iprot.readMessageEnd()
3544 
      raise x
3545 
    result = validateReturnProduct_result()
3546 
    result.read(self._iprot)
3547 
    self._iprot.readMessageEnd()
3548 
    if result.success is not None:
3549 
      return result.success
3550 
    if result.ex is not None:
3551 
      raise result.ex
3552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3553 
 
2616 chandransh 3554 
  def reshipOrder(self, orderId):
3555 
    """
4484 rajveer 3556 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3557 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3558 
    	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 3559 
 
3560 
    If the order is in DOA_CERT_VALID state, it does the following:
3561 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3562 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3563 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3564 
 
2616 chandransh 3565 
    Returns the id of the newly created order.
3431 rajveer 3566 
 
2616 chandransh 3567 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3568 
 
2616 chandransh 3569 
    Parameters:
3570 
     - orderId
3571 
    """
3572 
    self.send_reshipOrder(orderId)
3573 
    return self.recv_reshipOrder()
2591 chandransh 3574 
 
2616 chandransh 3575 
  def send_reshipOrder(self, orderId):
3576 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3577 
    args = reshipOrder_args()
3578 
    args.orderId = orderId
3579 
    args.write(self._oprot)
3580 
    self._oprot.writeMessageEnd()
3581 
    self._oprot.trans.flush()
3582 
 
3583 
  def recv_reshipOrder(self, ):
3584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3585 
    if mtype == TMessageType.EXCEPTION:
3586 
      x = TApplicationException()
3587 
      x.read(self._iprot)
3588 
      self._iprot.readMessageEnd()
3589 
      raise x
3590 
    result = reshipOrder_result()
3591 
    result.read(self._iprot)
3592 
    self._iprot.readMessageEnd()
3431 rajveer 3593 
    if result.success is not None:
2616 chandransh 3594 
      return result.success
3431 rajveer 3595 
    if result.ex is not None:
2616 chandransh 3596 
      raise result.ex
3597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3598 
 
3226 chandransh 3599 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3600 
    """
4484 rajveer 3601 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3602 
    	1. Creates a refund request for batch processing.
3603 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3604 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3605 
 
2616 chandransh 3606 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3607 
    	1. Creates a refund request for batch processing.
3226 chandransh 3608 
    	2. Cancels the reservation of the item in the warehouse.
3609 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3610 
 
3226 chandransh 3611 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3612 
    	1. Cancels the reservation of the item in the warehouse.
3613 
    	2. Marks the current order as CANCELED.
3614 
 
3615 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3616 
 
2616 chandransh 3617 
    Returns True if it is successful, False otherwise.
3431 rajveer 3618 
 
2616 chandransh 3619 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3620 
 
2616 chandransh 3621 
    Parameters:
3622 
     - orderId
3226 chandransh 3623 
     - refundedBy
3624 
     - reason
2616 chandransh 3625 
    """
3226 chandransh 3626 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3627 
    return self.recv_refundOrder()
3628 
 
3226 chandransh 3629 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3630 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3631 
    args = refundOrder_args()
3632 
    args.orderId = orderId
3226 chandransh 3633 
    args.refundedBy = refundedBy
3634 
    args.reason = reason
2616 chandransh 3635 
    args.write(self._oprot)
3636 
    self._oprot.writeMessageEnd()
3637 
    self._oprot.trans.flush()
3638 
 
3639 
  def recv_refundOrder(self, ):
3640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3641 
    if mtype == TMessageType.EXCEPTION:
3642 
      x = TApplicationException()
3643 
      x.read(self._iprot)
3644 
      self._iprot.readMessageEnd()
3645 
      raise x
3646 
    result = refundOrder_result()
3647 
    result.read(self._iprot)
3648 
    self._iprot.readMessageEnd()
3431 rajveer 3649 
    if result.success is not None:
2616 chandransh 3650 
      return result.success
3431 rajveer 3651 
    if result.ex is not None:
2616 chandransh 3652 
      raise result.ex
3653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3654 
 
2690 chandransh 3655 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3656 
    """
3657 
    Get all return orders created between the from and to dates for the given warehouse.
3658 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3659 
 
2690 chandransh 3660 
    Parameters:
3661 
     - warehouseId
3662 
     - fromDate
3663 
     - toDate
3664 
    """
3665 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3666 
    return self.recv_getReturnOrders()
2616 chandransh 3667 
 
2690 chandransh 3668 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3669 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3670 
    args = getReturnOrders_args()
3671 
    args.warehouseId = warehouseId
3672 
    args.fromDate = fromDate
3673 
    args.toDate = toDate
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_getReturnOrders(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = getReturnOrders_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3431 rajveer 3688 
    if result.success is not None:
2690 chandransh 3689 
      return result.success
3690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3691 
 
5481 phani.kuma 3692 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3693 
    """
3694 
    Get all return orders created between the from and to dates.
3695 
 
3696 
    Parameters:
3697 
     - onlyNotProcessed
3698 
     - fromDate
3699 
     - toDate
3700 
    """
3701 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3702 
    return self.recv_getAllReturnOrders()
3703 
 
3704 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3705 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3706 
    args = getAllReturnOrders_args()
3707 
    args.onlyNotProcessed = onlyNotProcessed
3708 
    args.fromDate = fromDate
3709 
    args.toDate = toDate
3710 
    args.write(self._oprot)
3711 
    self._oprot.writeMessageEnd()
3712 
    self._oprot.trans.flush()
3713 
 
3714 
  def recv_getAllReturnOrders(self, ):
3715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3716 
    if mtype == TMessageType.EXCEPTION:
3717 
      x = TApplicationException()
3718 
      x.read(self._iprot)
3719 
      self._iprot.readMessageEnd()
3720 
      raise x
3721 
    result = getAllReturnOrders_result()
3722 
    result.read(self._iprot)
3723 
    self._iprot.readMessageEnd()
3724 
    if result.success is not None:
3725 
      return result.success
3726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3727 
 
2700 chandransh 3728 
  def getReturnOrder(self, id):
3729 
    """
3730 
    Returns the ReturnOrder corresponding to the given id.
3731 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3732 
 
2700 chandransh 3733 
    Parameters:
3734 
     - id
3735 
    """
3736 
    self.send_getReturnOrder(id)
3737 
    return self.recv_getReturnOrder()
3738 
 
3739 
  def send_getReturnOrder(self, id):
3740 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3741 
    args = getReturnOrder_args()
3742 
    args.id = id
3743 
    args.write(self._oprot)
3744 
    self._oprot.writeMessageEnd()
3745 
    self._oprot.trans.flush()
3746 
 
3747 
  def recv_getReturnOrder(self, ):
3748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3749 
    if mtype == TMessageType.EXCEPTION:
3750 
      x = TApplicationException()
3751 
      x.read(self._iprot)
3752 
      self._iprot.readMessageEnd()
3753 
      raise x
3754 
    result = getReturnOrder_result()
3755 
    result.read(self._iprot)
3756 
    self._iprot.readMessageEnd()
3431 rajveer 3757 
    if result.success is not None:
2700 chandransh 3758 
      return result.success
3431 rajveer 3759 
    if result.ex is not None:
2700 chandransh 3760 
      raise result.ex
3761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3762 
 
2690 chandransh 3763 
  def processReturn(self, returnOrderId):
3764 
    """
3765 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3766 
 
2690 chandransh 3767 
    Parameters:
3768 
     - returnOrderId
3769 
    """
3770 
    self.send_processReturn(returnOrderId)
3771 
    self.recv_processReturn()
3772 
 
3773 
  def send_processReturn(self, returnOrderId):
3774 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3775 
    args = processReturn_args()
3776 
    args.returnOrderId = returnOrderId
3777 
    args.write(self._oprot)
3778 
    self._oprot.writeMessageEnd()
3779 
    self._oprot.trans.flush()
3780 
 
3781 
  def recv_processReturn(self, ):
3782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3783 
    if mtype == TMessageType.EXCEPTION:
3784 
      x = TApplicationException()
3785 
      x.read(self._iprot)
3786 
      self._iprot.readMessageEnd()
3787 
      raise x
3788 
    result = processReturn_result()
3789 
    result.read(self._iprot)
3790 
    self._iprot.readMessageEnd()
3431 rajveer 3791 
    if result.ex is not None:
2690 chandransh 3792 
      raise result.ex
3793 
    return
3794 
 
3451 chandransh 3795 
  def updateWeight(self, orderId, weight):
3796 
    """
3797 
    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 3798 
 
3451 chandransh 3799 
    Parameters:
3800 
     - orderId
3801 
     - weight
3802 
    """
3803 
    self.send_updateWeight(orderId, weight)
3804 
    return self.recv_updateWeight()
3805 
 
3806 
  def send_updateWeight(self, orderId, weight):
3807 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3808 
    args = updateWeight_args()
3809 
    args.orderId = orderId
3810 
    args.weight = weight
3811 
    args.write(self._oprot)
3812 
    self._oprot.writeMessageEnd()
3813 
    self._oprot.trans.flush()
3814 
 
3815 
  def recv_updateWeight(self, ):
3816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3817 
    if mtype == TMessageType.EXCEPTION:
3818 
      x = TApplicationException()
3819 
      x.read(self._iprot)
3820 
      self._iprot.readMessageEnd()
3821 
      raise x
3822 
    result = updateWeight_result()
3823 
    result.read(self._iprot)
3824 
    self._iprot.readMessageEnd()
3825 
    if result.success is not None:
3826 
      return result.success
3827 
    if result.ex is not None:
3828 
      raise result.ex
3829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3830 
 
3469 chandransh 3831 
  def changeItem(self, orderId, itemId):
3832 
    """
3833 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3834 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3835 
 
3469 chandransh 3836 
    Parameters:
3837 
     - orderId
3838 
     - itemId
3839 
    """
3840 
    self.send_changeItem(orderId, itemId)
3841 
    return self.recv_changeItem()
3842 
 
3843 
  def send_changeItem(self, orderId, itemId):
3844 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3845 
    args = changeItem_args()
3846 
    args.orderId = orderId
3847 
    args.itemId = itemId
3848 
    args.write(self._oprot)
3849 
    self._oprot.writeMessageEnd()
3850 
    self._oprot.trans.flush()
3851 
 
3852 
  def recv_changeItem(self, ):
3853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3854 
    if mtype == TMessageType.EXCEPTION:
3855 
      x = TApplicationException()
3856 
      x.read(self._iprot)
3857 
      self._iprot.readMessageEnd()
3858 
      raise x
3859 
    result = changeItem_result()
3860 
    result.read(self._iprot)
3861 
    self._iprot.readMessageEnd()
3862 
    if result.success is not None:
3863 
      return result.success
3864 
    if result.ex is not None:
3865 
      raise result.ex
3866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3867 
 
3868 
  def shiftToWarehouse(self, orderId, warehouseId):
3869 
    """
3870 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3871 
 
3872 
    Parameters:
3873 
     - orderId
3874 
     - warehouseId
3875 
    """
3876 
    self.send_shiftToWarehouse(orderId, warehouseId)
3877 
    return self.recv_shiftToWarehouse()
3878 
 
3879 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3880 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3881 
    args = shiftToWarehouse_args()
3882 
    args.orderId = orderId
3883 
    args.warehouseId = warehouseId
3884 
    args.write(self._oprot)
3885 
    self._oprot.writeMessageEnd()
3886 
    self._oprot.trans.flush()
3887 
 
3888 
  def recv_shiftToWarehouse(self, ):
3889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3890 
    if mtype == TMessageType.EXCEPTION:
3891 
      x = TApplicationException()
3892 
      x.read(self._iprot)
3893 
      self._iprot.readMessageEnd()
3894 
      raise x
3895 
    result = shiftToWarehouse_result()
3896 
    result.read(self._iprot)
3897 
    self._iprot.readMessageEnd()
3898 
    if result.success is not None:
3899 
      return result.success
3900 
    if result.ex is not None:
3901 
      raise result.ex
3902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3903 
 
4647 rajveer 3904 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3905 
    """
3906 
    Adds the given delay reason to the given order.
3986 chandransh 3907 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3908 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3909 
 
3553 chandransh 3910 
    Parameters:
3911 
     - orderId
3912 
     - delayReason
3986 chandransh 3913 
     - furtherDelay
4647 rajveer 3914 
     - delayReasonText
3553 chandransh 3915 
    """
4647 rajveer 3916 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3917 
    return self.recv_addDelayReason()
3918 
 
4647 rajveer 3919 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3920 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3921 
    args = addDelayReason_args()
3922 
    args.orderId = orderId
3923 
    args.delayReason = delayReason
3986 chandransh 3924 
    args.furtherDelay = furtherDelay
4647 rajveer 3925 
    args.delayReasonText = delayReasonText
3553 chandransh 3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_addDelayReason(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = addDelayReason_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3940 
    if result.success is not None:
3941 
      return result.success
3942 
    if result.ex is not None:
3943 
      raise result.ex
3944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3945 
 
3956 chandransh 3946 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3947 
    """
3948 
    Marks the COD orders with given AWB nos. as having been processed.
3949 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3950 
 
3956 chandransh 3951 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3952 
    1. There is no order corresponding to an AWB number.
3953 
    2. The captured amount for a payment exceeds the total payment.
3954 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3955 
 
3956 
    Parameters:
3957 
     - collectedAmountMap
3958 
     - xferBy
3959 
     - xferTxnId
3960 
     - xferDate
3961 
    """
3962 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3963 
    return self.recv_reconcileCodCollection()
3964 
 
3965 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3966 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3967 
    args = reconcileCodCollection_args()
3968 
    args.collectedAmountMap = collectedAmountMap
3969 
    args.xferBy = xferBy
3970 
    args.xferTxnId = xferTxnId
3971 
    args.xferDate = xferDate
3972 
    args.write(self._oprot)
3973 
    self._oprot.writeMessageEnd()
3974 
    self._oprot.trans.flush()
3975 
 
3976 
  def recv_reconcileCodCollection(self, ):
3977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3978 
    if mtype == TMessageType.EXCEPTION:
3979 
      x = TApplicationException()
3980 
      x.read(self._iprot)
3981 
      self._iprot.readMessageEnd()
3982 
      raise x
3983 
    result = reconcileCodCollection_result()
3984 
    result.read(self._iprot)
3985 
    self._iprot.readMessageEnd()
3986 
    if result.success is not None:
3987 
      return result.success
3988 
    if result.ex is not None:
3989 
      raise result.ex
3990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3991 
 
4008 mandeep.dh 3992 
  def getTransactionsRequiringExtraProcessing(self, category):
3993 
    """
4065 mandeep.dh 3994 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3995 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3996 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3997 
 
4008 mandeep.dh 3998 
    Parameters:
3999 
     - category
4000 
    """
4001 
    self.send_getTransactionsRequiringExtraProcessing(category)
4002 
    return self.recv_getTransactionsRequiringExtraProcessing()
4003 
 
4004 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4005 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4006 
    args = getTransactionsRequiringExtraProcessing_args()
4007 
    args.category = category
4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = getTransactionsRequiringExtraProcessing_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
4022 
    if result.success is not None:
4023 
      return result.success
4024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4025 
 
4026 
  def markTransactionAsProcessed(self, transactionId, category):
4027 
    """
4028 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4029 
    It essentially deletes the transaction id record for a particular
4030 
    processing type category (if present) from DB.
4031 
    This is currently used by CRM application.
4008 mandeep.dh 4032 
 
4033 
    Parameters:
4034 
     - transactionId
4035 
     - category
4036 
    """
4037 
    self.send_markTransactionAsProcessed(transactionId, category)
4038 
    self.recv_markTransactionAsProcessed()
4039 
 
4040 
  def send_markTransactionAsProcessed(self, transactionId, category):
4041 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4042 
    args = markTransactionAsProcessed_args()
4043 
    args.transactionId = transactionId
4044 
    args.category = category
4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_markTransactionAsProcessed(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = markTransactionAsProcessed_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
4059 
    return
4060 
 
4018 chandransh 4061 
  def getItemWiseRiskyOrdersCount(self, ):
4062 
    """
4063 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4064 
    is defined as one whose shipping date is about to expire.
4065 
    """
4066 
    self.send_getItemWiseRiskyOrdersCount()
4067 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4068 
 
4018 chandransh 4069 
  def send_getItemWiseRiskyOrdersCount(self, ):
4070 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4071 
    args = getItemWiseRiskyOrdersCount_args()
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = getItemWiseRiskyOrdersCount_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
4088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4089 
 
4295 varun.gupt 4090 
  def getOrdersForItemIds(self, itemIds):
4091 
    """
4092 
    Returns a list of all orders which have items with given id
4093 
 
4094 
    Parameters:
4095 
     - itemIds
4096 
    """
4097 
    self.send_getOrdersForItemIds(itemIds)
4098 
    return self.recv_getOrdersForItemIds()
4099 
 
4100 
  def send_getOrdersForItemIds(self, itemIds):
4101 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4102 
    args = getOrdersForItemIds_args()
4103 
    args.itemIds = itemIds
4104 
    args.write(self._oprot)
4105 
    self._oprot.writeMessageEnd()
4106 
    self._oprot.trans.flush()
4107 
 
4108 
  def recv_getOrdersForItemIds(self, ):
4109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4110 
    if mtype == TMessageType.EXCEPTION:
4111 
      x = TApplicationException()
4112 
      x.read(self._iprot)
4113 
      self._iprot.readMessageEnd()
4114 
      raise x
4115 
    result = getOrdersForItemIds_result()
4116 
    result.read(self._iprot)
4117 
    self._iprot.readMessageEnd()
4118 
    if result.success is not None:
4119 
      return result.success
4120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4121 
 
4247 rajveer 4122 
  def markOrderCancellationRequestReceived(self, orderId):
4123 
    """
4124 
    Mark order as cancellation request received. If customer sends request of cancellation of
4125 
    a particular order, this method will be called. It will just change status of the order
4126 
    depending on its current status. It also records the previous status, so that we can move
4127 
    back to that status if cancellation request is denied.
4018 chandransh 4128 
 
4247 rajveer 4129 
    Parameters:
4130 
     - orderId
4131 
    """
4132 
    self.send_markOrderCancellationRequestReceived(orderId)
4133 
    self.recv_markOrderCancellationRequestReceived()
4134 
 
4135 
  def send_markOrderCancellationRequestReceived(self, orderId):
4136 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4137 
    args = markOrderCancellationRequestReceived_args()
4138 
    args.orderId = orderId
4139 
    args.write(self._oprot)
4140 
    self._oprot.writeMessageEnd()
4141 
    self._oprot.trans.flush()
4142 
 
4143 
  def recv_markOrderCancellationRequestReceived(self, ):
4144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4145 
    if mtype == TMessageType.EXCEPTION:
4146 
      x = TApplicationException()
4147 
      x.read(self._iprot)
4148 
      self._iprot.readMessageEnd()
4149 
      raise x
4150 
    result = markOrderCancellationRequestReceived_result()
4151 
    result.read(self._iprot)
4152 
    self._iprot.readMessageEnd()
4153 
    if result.ex is not None:
4154 
      raise result.ex
4155 
    return
4156 
 
4157 
  def markOrderCancellationRequestConfirmed(self, orderId):
4158 
    """
4159 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4160 
    cancellation request confirmed. After this OM will be able to cancel the order.
4161 
 
4162 
    Parameters:
4163 
     - orderId
4164 
    """
4165 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4166 
    self.recv_markOrderCancellationRequestConfirmed()
4167 
 
4168 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4169 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4170 
    args = markOrderCancellationRequestConfirmed_args()
4171 
    args.orderId = orderId
4172 
    args.write(self._oprot)
4173 
    self._oprot.writeMessageEnd()
4174 
    self._oprot.trans.flush()
4175 
 
4176 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4178 
    if mtype == TMessageType.EXCEPTION:
4179 
      x = TApplicationException()
4180 
      x.read(self._iprot)
4181 
      self._iprot.readMessageEnd()
4182 
      raise x
4183 
    result = markOrderCancellationRequestConfirmed_result()
4184 
    result.read(self._iprot)
4185 
    self._iprot.readMessageEnd()
4186 
    if result.ex is not None:
4187 
      raise result.ex
4188 
    return
4189 
 
4190 
  def markOrderCancellationRequestDenied(self, orderId):
4191 
    """
4192 
    If we decide to not to cancel order, we will move the order ro previous status.
4193 
 
4194 
    Parameters:
4195 
     - orderId
4196 
    """
4197 
    self.send_markOrderCancellationRequestDenied(orderId)
4198 
    self.recv_markOrderCancellationRequestDenied()
4199 
 
4200 
  def send_markOrderCancellationRequestDenied(self, orderId):
4201 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4202 
    args = markOrderCancellationRequestDenied_args()
4203 
    args.orderId = orderId
4204 
    args.write(self._oprot)
4205 
    self._oprot.writeMessageEnd()
4206 
    self._oprot.trans.flush()
4207 
 
4208 
  def recv_markOrderCancellationRequestDenied(self, ):
4209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4210 
    if mtype == TMessageType.EXCEPTION:
4211 
      x = TApplicationException()
4212 
      x.read(self._iprot)
4213 
      self._iprot.readMessageEnd()
4214 
      raise x
4215 
    result = markOrderCancellationRequestDenied_result()
4216 
    result.read(self._iprot)
4217 
    self._iprot.readMessageEnd()
4218 
    if result.ex is not None:
4219 
      raise result.ex
4220 
    return
4221 
 
4258 rajveer 4222 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4223 
    """
4258 rajveer 4224 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4225 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4226 
 
4227 
    Parameters:
4258 rajveer 4228 
     - transactionId
4247 rajveer 4229 
    """
4258 rajveer 4230 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4231 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4232 
 
4258 rajveer 4233 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4234 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4235 
    args = markTransactionAsPaymentFlagRemoved_args()
4236 
    args.transactionId = transactionId
4247 rajveer 4237 
    args.write(self._oprot)
4238 
    self._oprot.writeMessageEnd()
4239 
    self._oprot.trans.flush()
4240 
 
4258 rajveer 4241 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4243 
    if mtype == TMessageType.EXCEPTION:
4244 
      x = TApplicationException()
4245 
      x.read(self._iprot)
4246 
      self._iprot.readMessageEnd()
4247 
      raise x
4258 rajveer 4248 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4249 
    result.read(self._iprot)
4250 
    self._iprot.readMessageEnd()
4251 
    if result.ex is not None:
4252 
      raise result.ex
4253 
    return
4254 
 
4259 anupam.sin 4255 
  def refundTransaction(self, transactionId, refundedBy, reason):
4256 
    """
4257 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4258 
    need to be cancelled
4247 rajveer 4259 
 
4259 anupam.sin 4260 
    Parameters:
4261 
     - transactionId
4262 
     - refundedBy
4263 
     - reason
4264 
    """
4265 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4266 
    self.recv_refundTransaction()
4267 
 
4268 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4269 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4270 
    args = refundTransaction_args()
4271 
    args.transactionId = transactionId
4272 
    args.refundedBy = refundedBy
4273 
    args.reason = reason
4274 
    args.write(self._oprot)
4275 
    self._oprot.writeMessageEnd()
4276 
    self._oprot.trans.flush()
4277 
 
4278 
  def recv_refundTransaction(self, ):
4279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4280 
    if mtype == TMessageType.EXCEPTION:
4281 
      x = TApplicationException()
4282 
      x.read(self._iprot)
4283 
      self._iprot.readMessageEnd()
4284 
      raise x
4285 
    result = refundTransaction_result()
4286 
    result.read(self._iprot)
4287 
    self._iprot.readMessageEnd()
4288 
    if result.ex is not None:
4289 
      raise result.ex
4290 
    return
4291 
 
4324 mandeep.dh 4292 
  def updateShipmentAddress(self, orderId, addressId):
4293 
    """
4294 
    Updates shipment address of an order. Delivery and shipping date estimates
4295 
    etc. are also updated here.
4296 
 
4297 
    Throws TransactionServiceException in case address change is not
4298 
    possible due to certain reasons such as new pincode in address is
4299 
    not serviceable etc.
4300 
 
4301 
    Parameters:
4302 
     - orderId
4303 
     - addressId
4304 
    """
4305 
    self.send_updateShipmentAddress(orderId, addressId)
4306 
    self.recv_updateShipmentAddress()
4307 
 
4308 
  def send_updateShipmentAddress(self, orderId, addressId):
4309 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4310 
    args = updateShipmentAddress_args()
4311 
    args.orderId = orderId
4312 
    args.addressId = addressId
4313 
    args.write(self._oprot)
4314 
    self._oprot.writeMessageEnd()
4315 
    self._oprot.trans.flush()
4316 
 
4317 
  def recv_updateShipmentAddress(self, ):
4318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4319 
    if mtype == TMessageType.EXCEPTION:
4320 
      x = TApplicationException()
4321 
      x.read(self._iprot)
4322 
      self._iprot.readMessageEnd()
4323 
      raise x
4324 
    result = updateShipmentAddress_result()
4325 
    result.read(self._iprot)
4326 
    self._iprot.readMessageEnd()
4327 
    if result.ex is not None:
4328 
      raise result.ex
4329 
    return
4330 
 
4285 rajveer 4331 
  def acceptOrdersForItemId(self, itemId, inventory):
4332 
    """
4333 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4334 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4335 
 
4285 rajveer 4336 
    Parameters:
4337 
     - itemId
4338 
     - inventory
4339 
    """
4340 
    self.send_acceptOrdersForItemId(itemId, inventory)
4341 
    return self.recv_acceptOrdersForItemId()
4342 
 
4343 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4344 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4345 
    args = acceptOrdersForItemId_args()
4346 
    args.itemId = itemId
4347 
    args.inventory = inventory
4348 
    args.write(self._oprot)
4349 
    self._oprot.writeMessageEnd()
4350 
    self._oprot.trans.flush()
4351 
 
4352 
  def recv_acceptOrdersForItemId(self, ):
4353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4354 
    if mtype == TMessageType.EXCEPTION:
4355 
      x = TApplicationException()
4356 
      x.read(self._iprot)
4357 
      self._iprot.readMessageEnd()
4358 
      raise x
4359 
    result = acceptOrdersForItemId_result()
4360 
    result.read(self._iprot)
4361 
    self._iprot.readMessageEnd()
4362 
    if result.success is not None:
4363 
      return result.success
4364 
    if result.ex is not None:
4365 
      raise result.ex
4366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4367 
 
4369 rajveer 4368 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4369 
    """
4370 
    Parameters:
4371 
     - vendorId
4372 
     - itemId
4373 
     - quantity
4374 
     - estimate
4369 rajveer 4375 
     - isReminder
4303 rajveer 4376 
    """
4369 rajveer 4377 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4378 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4379 
 
4369 rajveer 4380 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4381 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4382 
    args = markOrdersAsPORaised_args()
4383 
    args.vendorId = vendorId
4384 
    args.itemId = itemId
4385 
    args.quantity = quantity
4386 
    args.estimate = estimate
4369 rajveer 4387 
    args.isReminder = isReminder
4303 rajveer 4388 
    args.write(self._oprot)
4389 
    self._oprot.writeMessageEnd()
4390 
    self._oprot.trans.flush()
4391 
 
4392 
  def recv_markOrdersAsPORaised(self, ):
4393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4394 
    if mtype == TMessageType.EXCEPTION:
4395 
      x = TApplicationException()
4396 
      x.read(self._iprot)
4397 
      self._iprot.readMessageEnd()
4398 
      raise x
4399 
    result = markOrdersAsPORaised_result()
4400 
    result.read(self._iprot)
4401 
    self._iprot.readMessageEnd()
4402 
    if result.ex is not None:
4403 
      raise result.ex
4404 
    return
4405 
 
4369 rajveer 4406 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4407 
    """
4408 
    Parameters:
4409 
     - vendorId
4410 
     - itemId
4411 
     - quantity
4412 
     - estimate
4369 rajveer 4413 
     - isReminder
4303 rajveer 4414 
    """
4369 rajveer 4415 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4416 
    self.recv_markOrdersAsReversalInitiated()
4417 
 
4369 rajveer 4418 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4419 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4420 
    args = markOrdersAsReversalInitiated_args()
4421 
    args.vendorId = vendorId
4422 
    args.itemId = itemId
4423 
    args.quantity = quantity
4424 
    args.estimate = estimate
4369 rajveer 4425 
    args.isReminder = isReminder
4303 rajveer 4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_markOrdersAsReversalInitiated(self, ):
4431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4432 
    if mtype == TMessageType.EXCEPTION:
4433 
      x = TApplicationException()
4434 
      x.read(self._iprot)
4435 
      self._iprot.readMessageEnd()
4436 
      raise x
4437 
    result = markOrdersAsReversalInitiated_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.ex is not None:
4441 
      raise result.ex
4442 
    return
4443 
 
4369 rajveer 4444 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4445 
    """
4446 
    Parameters:
4447 
     - vendorId
4448 
     - itemId
4449 
     - quantity
4450 
     - estimate
4369 rajveer 4451 
     - isReminder
4303 rajveer 4452 
    """
4369 rajveer 4453 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4454 
    self.recv_markOrdersAsNotAvailabke()
4455 
 
4369 rajveer 4456 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4457 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4458 
    args = markOrdersAsNotAvailabke_args()
4459 
    args.vendorId = vendorId
4460 
    args.itemId = itemId
4461 
    args.quantity = quantity
4462 
    args.estimate = estimate
4369 rajveer 4463 
    args.isReminder = isReminder
4303 rajveer 4464 
    args.write(self._oprot)
4465 
    self._oprot.writeMessageEnd()
4466 
    self._oprot.trans.flush()
4467 
 
4468 
  def recv_markOrdersAsNotAvailabke(self, ):
4469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4470 
    if mtype == TMessageType.EXCEPTION:
4471 
      x = TApplicationException()
4472 
      x.read(self._iprot)
4473 
      self._iprot.readMessageEnd()
4474 
      raise x
4475 
    result = markOrdersAsNotAvailabke_result()
4476 
    result.read(self._iprot)
4477 
    self._iprot.readMessageEnd()
4478 
    if result.ex is not None:
4479 
      raise result.ex
4480 
    return
4481 
 
4369 rajveer 4482 
  def markOrdersAsTimeout(self, vendorId):
4483 
    """
4484 
    Parameters:
4485 
     - vendorId
4486 
    """
4487 
    self.send_markOrdersAsTimeout(vendorId)
4488 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4489 
 
4369 rajveer 4490 
  def send_markOrdersAsTimeout(self, vendorId):
4491 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4492 
    args = markOrdersAsTimeout_args()
4493 
    args.vendorId = vendorId
4494 
    args.write(self._oprot)
4495 
    self._oprot.writeMessageEnd()
4496 
    self._oprot.trans.flush()
4497 
 
4498 
  def recv_markOrdersAsTimeout(self, ):
4499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4500 
    if mtype == TMessageType.EXCEPTION:
4501 
      x = TApplicationException()
4502 
      x.read(self._iprot)
4503 
      self._iprot.readMessageEnd()
4504 
      raise x
4505 
    result = markOrdersAsTimeout_result()
4506 
    result.read(self._iprot)
4507 
    self._iprot.readMessageEnd()
4508 
    if result.success is not None:
4509 
      return result.success
4510 
    if result.ex is not None:
4511 
      raise result.ex
4512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4513 
 
4662 rajveer 4514 
  def markOrderAsLostInTransit(self, orderId):
4515 
    """
4516 
    Mark order as LOST_IN_TRANSIT
4517 
 
4518 
    Parameters:
4519 
     - orderId
4520 
    """
4521 
    self.send_markOrderAsLostInTransit(orderId)
4522 
    return self.recv_markOrderAsLostInTransit()
4523 
 
4524 
  def send_markOrderAsLostInTransit(self, orderId):
4525 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4526 
    args = markOrderAsLostInTransit_args()
4527 
    args.orderId = orderId
4528 
    args.write(self._oprot)
4529 
    self._oprot.writeMessageEnd()
4530 
    self._oprot.trans.flush()
4531 
 
4532 
  def recv_markOrderAsLostInTransit(self, ):
4533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4534 
    if mtype == TMessageType.EXCEPTION:
4535 
      x = TApplicationException()
4536 
      x.read(self._iprot)
4537 
      self._iprot.readMessageEnd()
4538 
      raise x
4539 
    result = markOrderAsLostInTransit_result()
4540 
    result.read(self._iprot)
4541 
    self._iprot.readMessageEnd()
4542 
    if result.success is not None:
4543 
      return result.success
4544 
    if result.ex is not None:
4545 
      raise result.ex
4546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4547 
 
4386 anupam.sin 4548 
  def getOrderForAwb(self, awb):
4549 
    """
4550 
    Returns the order corresponding to an AWB number
4369 rajveer 4551 
 
4386 anupam.sin 4552 
    Parameters:
4553 
     - awb
4554 
    """
4555 
    self.send_getOrderForAwb(awb)
4556 
    return self.recv_getOrderForAwb()
4557 
 
4558 
  def send_getOrderForAwb(self, awb):
4559 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4560 
    args = getOrderForAwb_args()
4561 
    args.awb = awb
4562 
    args.write(self._oprot)
4563 
    self._oprot.writeMessageEnd()
4564 
    self._oprot.trans.flush()
4565 
 
4566 
  def recv_getOrderForAwb(self, ):
4567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4568 
    if mtype == TMessageType.EXCEPTION:
4569 
      x = TApplicationException()
4570 
      x.read(self._iprot)
4571 
      self._iprot.readMessageEnd()
4572 
      raise x
4573 
    result = getOrderForAwb_result()
4574 
    result.read(self._iprot)
4575 
    self._iprot.readMessageEnd()
4576 
    if result.success is not None:
4577 
      return result.success
4578 
    if result.ex is not None:
4579 
      raise result.ex
4580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4581 
 
4910 phani.kuma 4582 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4583 
    """
4910 phani.kuma 4584 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4585 
 
4506 phani.kuma 4586 
    Parameters:
4587 
     - logistics_provider_id
4910 phani.kuma 4588 
     - order_status_list
4506 phani.kuma 4589 
    """
4910 phani.kuma 4590 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4591 
    return self.recv_getOrdersForProviderForStatus()
4592 
 
4910 phani.kuma 4593 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4594 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4595 
    args = getOrdersForProviderForStatus_args()
4596 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4597 
    args.order_status_list = order_status_list
4506 phani.kuma 4598 
    args.write(self._oprot)
4599 
    self._oprot.writeMessageEnd()
4600 
    self._oprot.trans.flush()
4601 
 
4602 
  def recv_getOrdersForProviderForStatus(self, ):
4603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4604 
    if mtype == TMessageType.EXCEPTION:
4605 
      x = TApplicationException()
4606 
      x.read(self._iprot)
4607 
      self._iprot.readMessageEnd()
4608 
      raise x
4609 
    result = getOrdersForProviderForStatus_result()
4610 
    result.read(self._iprot)
4611 
    self._iprot.readMessageEnd()
4612 
    if result.success is not None:
4613 
      return result.success
4614 
    if result.ex is not None:
4615 
      raise result.ex
4616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4617 
 
4600 varun.gupt 4618 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4619 
    """
4620 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4621 
 
4600 varun.gupt 4622 
    Parameters:
4623 
     - vendorId
4624 
     - billingDateFrom
4625 
     - billingDateTo
4626 
    """
4627 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4628 
    return self.recv_getBilledOrdersForVendor()
4629 
 
4630 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4631 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4632 
    args = getBilledOrdersForVendor_args()
4633 
    args.vendorId = vendorId
4634 
    args.billingDateFrom = billingDateFrom
4635 
    args.billingDateTo = billingDateTo
4636 
    args.write(self._oprot)
4637 
    self._oprot.writeMessageEnd()
4638 
    self._oprot.trans.flush()
4639 
 
4640 
  def recv_getBilledOrdersForVendor(self, ):
4641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4642 
    if mtype == TMessageType.EXCEPTION:
4643 
      x = TApplicationException()
4644 
      x.read(self._iprot)
4645 
      self._iprot.readMessageEnd()
4646 
      raise x
4647 
    result = getBilledOrdersForVendor_result()
4648 
    result.read(self._iprot)
4649 
    self._iprot.readMessageEnd()
4650 
    if result.success is not None:
4651 
      return result.success
4652 
    if result.ex is not None:
4653 
      raise result.ex
4654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4655 
 
4607 rajveer 4656 
  def getSlippedSippingDateOrders(self, ):
4657 
    self.send_getSlippedSippingDateOrders()
4658 
    return self.recv_getSlippedSippingDateOrders()
4659 
 
4660 
  def send_getSlippedSippingDateOrders(self, ):
4661 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4662 
    args = getSlippedSippingDateOrders_args()
4663 
    args.write(self._oprot)
4664 
    self._oprot.writeMessageEnd()
4665 
    self._oprot.trans.flush()
4666 
 
4667 
  def recv_getSlippedSippingDateOrders(self, ):
4668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4669 
    if mtype == TMessageType.EXCEPTION:
4670 
      x = TApplicationException()
4671 
      x.read(self._iprot)
4672 
      self._iprot.readMessageEnd()
4673 
      raise x
4674 
    result = getSlippedSippingDateOrders_result()
4675 
    result.read(self._iprot)
4676 
    self._iprot.readMessageEnd()
4677 
    if result.success is not None:
4678 
      return result.success
4679 
    if result.ex is not None:
4680 
      raise result.ex
4681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4682 
 
4709 rajveer 4683 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4684 
    """
4685 
    Parameters:
4686 
     - cancelDateFrom
4687 
     - cancelDateTo
4688 
    """
4689 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4690 
    return self.recv_getCancelledOrders()
4691 
 
4692 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4693 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4694 
    args = getCancelledOrders_args()
4695 
    args.cancelDateFrom = cancelDateFrom
4696 
    args.cancelDateTo = cancelDateTo
4697 
    args.write(self._oprot)
4698 
    self._oprot.writeMessageEnd()
4699 
    self._oprot.trans.flush()
4700 
 
4701 
  def recv_getCancelledOrders(self, ):
4702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4703 
    if mtype == TMessageType.EXCEPTION:
4704 
      x = TApplicationException()
4705 
      x.read(self._iprot)
4706 
      self._iprot.readMessageEnd()
4707 
      raise x
4708 
    result = getCancelledOrders_result()
4709 
    result.read(self._iprot)
4710 
    self._iprot.readMessageEnd()
4711 
    if result.success is not None:
4712 
      return result.success
4713 
    if result.ex is not None:
4714 
      raise result.ex
4715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4716 
 
4600 varun.gupt 4717 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4718 
    """
4719 
    Parameters:
4720 
     - mapAWBAndAmount
4721 
    """
4722 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4723 
    self.recv_saveBluedartSettlements()
4724 
 
4725 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4726 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4727 
    args = saveBluedartSettlements_args()
4728 
    args.mapAWBAndAmount = mapAWBAndAmount
4729 
    args.write(self._oprot)
4730 
    self._oprot.writeMessageEnd()
4731 
    self._oprot.trans.flush()
4732 
 
4733 
  def recv_saveBluedartSettlements(self, ):
4734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4735 
    if mtype == TMessageType.EXCEPTION:
4736 
      x = TApplicationException()
4737 
      x.read(self._iprot)
4738 
      self._iprot.readMessageEnd()
4739 
      raise x
4740 
    result = saveBluedartSettlements_result()
4741 
    result.read(self._iprot)
4742 
    self._iprot.readMessageEnd()
4743 
    if result.ex is not None:
4744 
      raise result.ex
4745 
    return
4746 
 
4905 varun.gupt 4747 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4748 
    """
4749 
    Parameters:
4750 
     - settlementDate
4751 
     - paymentGatewayId
4905 varun.gupt 4752 
     - referenceId
4600 varun.gupt 4753 
     - serviceTax
4754 
     - otherCharges
4755 
     - netCollection
4756 
    """
4905 varun.gupt 4757 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4758 
    self.recv_savePaymentSettlements()
4759 
 
4905 varun.gupt 4760 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4761 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4762 
    args = savePaymentSettlements_args()
4763 
    args.settlementDate = settlementDate
4764 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4765 
    args.referenceId = referenceId
4600 varun.gupt 4766 
    args.serviceTax = serviceTax
4767 
    args.otherCharges = otherCharges
4768 
    args.netCollection = netCollection
4769 
    args.write(self._oprot)
4770 
    self._oprot.writeMessageEnd()
4771 
    self._oprot.trans.flush()
4772 
 
4773 
  def recv_savePaymentSettlements(self, ):
4774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4775 
    if mtype == TMessageType.EXCEPTION:
4776 
      x = TApplicationException()
4777 
      x.read(self._iprot)
4778 
      self._iprot.readMessageEnd()
4779 
      raise x
4780 
    result = savePaymentSettlements_result()
4781 
    result.read(self._iprot)
4782 
    self._iprot.readMessageEnd()
4783 
    if result.ex is not None:
4784 
      raise result.ex
4785 
    return
4786 
 
4787 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4788 
    """
4789 
    Parameters:
4790 
     - settlementId
4791 
     - settlementDate
4792 
     - transactionDateFrom
4793 
     - transactionDateTo
4794 
     - amount
4795 
    """
4796 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4797 
    self.recv_saveEBSSettlementSummary()
4798 
 
4799 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4800 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4801 
    args = saveEBSSettlementSummary_args()
4802 
    args.settlementId = settlementId
4803 
    args.settlementDate = settlementDate
4804 
    args.transactionDateFrom = transactionDateFrom
4805 
    args.transactionDateTo = transactionDateTo
4806 
    args.amount = amount
4807 
    args.write(self._oprot)
4808 
    self._oprot.writeMessageEnd()
4809 
    self._oprot.trans.flush()
4810 
 
4811 
  def recv_saveEBSSettlementSummary(self, ):
4812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4813 
    if mtype == TMessageType.EXCEPTION:
4814 
      x = TApplicationException()
4815 
      x.read(self._iprot)
4816 
      self._iprot.readMessageEnd()
4817 
      raise x
4818 
    result = saveEBSSettlementSummary_result()
4819 
    result.read(self._iprot)
4820 
    self._iprot.readMessageEnd()
4821 
    if result.ex is not None:
4822 
      raise result.ex
4823 
    return
4824 
 
5386 phani.kuma 4825 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4826 
    """
4827 
    Parameters:
5189 varun.gupt 4828 
     - referenceId
4829 
     - isRefund
4600 varun.gupt 4830 
    """
5386 phani.kuma 4831 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4832 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4833 
 
5386 phani.kuma 4834 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4835 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4836 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4837 
    args.referenceId = referenceId
4838 
    args.isRefund = isRefund
4600 varun.gupt 4839 
    args.write(self._oprot)
4840 
    self._oprot.writeMessageEnd()
4841 
    self._oprot.trans.flush()
4842 
 
5386 phani.kuma 4843 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4845 
    if mtype == TMessageType.EXCEPTION:
4846 
      x = TApplicationException()
4847 
      x.read(self._iprot)
4848 
      self._iprot.readMessageEnd()
4849 
      raise x
5386 phani.kuma 4850 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4851 
    result.read(self._iprot)
4852 
    self._iprot.readMessageEnd()
4853 
    if result.success is not None:
4854 
      return result.success
4855 
    if result.ex is not None:
4856 
      raise result.ex
5386 phani.kuma 4857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4858 
 
5386 phani.kuma 4859 
  def getSettlementForCod(self, orderId, isRefund):
4860 
    """
4861 
    Parameters:
4862 
     - orderId
4863 
     - isRefund
4864 
    """
4865 
    self.send_getSettlementForCod(orderId, isRefund)
4866 
    return self.recv_getSettlementForCod()
4867 
 
4868 
  def send_getSettlementForCod(self, orderId, isRefund):
4869 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4870 
    args = getSettlementForCod_args()
4871 
    args.orderId = orderId
4872 
    args.isRefund = isRefund
4873 
    args.write(self._oprot)
4874 
    self._oprot.writeMessageEnd()
4875 
    self._oprot.trans.flush()
4876 
 
4877 
  def recv_getSettlementForCod(self, ):
4878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4879 
    if mtype == TMessageType.EXCEPTION:
4880 
      x = TApplicationException()
4881 
      x.read(self._iprot)
4882 
      self._iprot.readMessageEnd()
4883 
      raise x
4884 
    result = getSettlementForCod_result()
4885 
    result.read(self._iprot)
4886 
    self._iprot.readMessageEnd()
4887 
    if result.success is not None:
4888 
      return result.success
4889 
    if result.ex is not None:
4890 
      raise result.ex
4891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4892 
 
4600 varun.gupt 4893 
  def getEBSSettlementSummaries(self, ):
4894 
    self.send_getEBSSettlementSummaries()
4895 
    return self.recv_getEBSSettlementSummaries()
4896 
 
4897 
  def send_getEBSSettlementSummaries(self, ):
4898 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4899 
    args = getEBSSettlementSummaries_args()
4900 
    args.write(self._oprot)
4901 
    self._oprot.writeMessageEnd()
4902 
    self._oprot.trans.flush()
4903 
 
4904 
  def recv_getEBSSettlementSummaries(self, ):
4905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4906 
    if mtype == TMessageType.EXCEPTION:
4907 
      x = TApplicationException()
4908 
      x.read(self._iprot)
4909 
      self._iprot.readMessageEnd()
4910 
      raise x
4911 
    result = getEBSSettlementSummaries_result()
4912 
    result.read(self._iprot)
4913 
    self._iprot.readMessageEnd()
4914 
    if result.success is not None:
4915 
      return result.success
4916 
    if result.ex is not None:
4917 
      raise result.ex
4918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4919 
 
4920 
  def markEBSSettlementUploaded(self, settlementId):
4921 
    """
4922 
    Parameters:
4923 
     - settlementId
4924 
    """
4925 
    self.send_markEBSSettlementUploaded(settlementId)
4926 
    self.recv_markEBSSettlementUploaded()
4927 
 
4928 
  def send_markEBSSettlementUploaded(self, settlementId):
4929 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4930 
    args = markEBSSettlementUploaded_args()
4931 
    args.settlementId = settlementId
4932 
    args.write(self._oprot)
4933 
    self._oprot.writeMessageEnd()
4934 
    self._oprot.trans.flush()
4935 
 
4936 
  def recv_markEBSSettlementUploaded(self, ):
4937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4938 
    if mtype == TMessageType.EXCEPTION:
4939 
      x = TApplicationException()
4940 
      x.read(self._iprot)
4941 
      self._iprot.readMessageEnd()
4942 
      raise x
4943 
    result = markEBSSettlementUploaded_result()
4944 
    result.read(self._iprot)
4945 
    self._iprot.readMessageEnd()
4946 
    if result.ex is not None:
4947 
      raise result.ex
4948 
    return
4949 
 
4950 
  def getEBSSettlementDate(self, settlementId):
4951 
    """
4952 
    Parameters:
4953 
     - settlementId
4954 
    """
4955 
    self.send_getEBSSettlementDate(settlementId)
4956 
    return self.recv_getEBSSettlementDate()
4957 
 
4958 
  def send_getEBSSettlementDate(self, settlementId):
4959 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4960 
    args = getEBSSettlementDate_args()
4961 
    args.settlementId = settlementId
4962 
    args.write(self._oprot)
4963 
    self._oprot.writeMessageEnd()
4964 
    self._oprot.trans.flush()
4965 
 
4966 
  def recv_getEBSSettlementDate(self, ):
4967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4968 
    if mtype == TMessageType.EXCEPTION:
4969 
      x = TApplicationException()
4970 
      x.read(self._iprot)
4971 
      self._iprot.readMessageEnd()
4972 
      raise x
4973 
    result = getEBSSettlementDate_result()
4974 
    result.read(self._iprot)
4975 
    self._iprot.readMessageEnd()
4976 
    if result.success is not None:
4977 
      return result.success
4978 
    if result.ex is not None:
4979 
      raise result.ex
4980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4981 
 
4715 varun.gupt 4982 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4983 
    """
4984 
    Parameters:
4985 
     - settlementDateFrom
4986 
     - settlementDateTo
4987 
     - isRefund
4988 
    """
4989 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4990 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4991 
 
4715 varun.gupt 4992 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4993 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4994 
    args = getSettlementsByDate_args()
4995 
    args.settlementDateFrom = settlementDateFrom
4996 
    args.settlementDateTo = settlementDateTo
4997 
    args.isRefund = isRefund
4998 
    args.write(self._oprot)
4999 
    self._oprot.writeMessageEnd()
5000 
    self._oprot.trans.flush()
5001 
 
5002 
  def recv_getSettlementsByDate(self, ):
5003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5004 
    if mtype == TMessageType.EXCEPTION:
5005 
      x = TApplicationException()
5006 
      x.read(self._iprot)
5007 
      self._iprot.readMessageEnd()
5008 
      raise x
5009 
    result = getSettlementsByDate_result()
5010 
    result.read(self._iprot)
5011 
    self._iprot.readMessageEnd()
5012 
    if result.success is not None:
5013 
      return result.success
5014 
    if result.ex is not None:
5015 
      raise result.ex
5016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5017 
 
5018 
  def getReshippedOrderIds(self, orderIds):
5019 
    """
5020 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5021 
 
5022 
    Parameters:
5023 
     - orderIds
5024 
    """
5025 
    self.send_getReshippedOrderIds(orderIds)
5026 
    return self.recv_getReshippedOrderIds()
5027 
 
5028 
  def send_getReshippedOrderIds(self, orderIds):
5029 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5030 
    args = getReshippedOrderIds_args()
5031 
    args.orderIds = orderIds
5032 
    args.write(self._oprot)
5033 
    self._oprot.writeMessageEnd()
5034 
    self._oprot.trans.flush()
5035 
 
5036 
  def recv_getReshippedOrderIds(self, ):
5037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5038 
    if mtype == TMessageType.EXCEPTION:
5039 
      x = TApplicationException()
5040 
      x.read(self._iprot)
5041 
      self._iprot.readMessageEnd()
5042 
      raise x
5043 
    result = getReshippedOrderIds_result()
5044 
    result.read(self._iprot)
5045 
    self._iprot.readMessageEnd()
5046 
    if result.success is not None:
5047 
      return result.success
5048 
    if result.ex is not None:
5049 
      raise result.ex
5050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5051 
 
5481 phani.kuma 5052 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5053 
    """
5054 
    Parameters:
5055 
     - vendorId
5481 phani.kuma 5056 
     - onlyVendorNotPaid
5057 
     - billingDateFrom
5058 
     - billingDateTo
4875 varun.gupt 5059 
    """
5481 phani.kuma 5060 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5061 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5062 
 
5481 phani.kuma 5063 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5064 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5065 
    args = getBilledOrders_args()
4875 varun.gupt 5066 
    args.vendorId = vendorId
5481 phani.kuma 5067 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5068 
    args.billingDateFrom = billingDateFrom
5069 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5070 
    args.write(self._oprot)
5071 
    self._oprot.writeMessageEnd()
5072 
    self._oprot.trans.flush()
5073 
 
5481 phani.kuma 5074 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5076 
    if mtype == TMessageType.EXCEPTION:
5077 
      x = TApplicationException()
5078 
      x.read(self._iprot)
5079 
      self._iprot.readMessageEnd()
5080 
      raise x
5481 phani.kuma 5081 
    result = getBilledOrders_result()
4875 varun.gupt 5082 
    result.read(self._iprot)
5083 
    self._iprot.readMessageEnd()
5084 
    if result.success is not None:
5085 
      return result.success
5086 
    if result.ex is not None:
5087 
      raise result.ex
5481 phani.kuma 5088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5089 
 
5031 varun.gupt 5090 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5091 
    """
5092 
    Parameters:
5093 
     - startDate
5094 
     - endDate
5095 
    """
5096 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5097 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5098 
 
5031 varun.gupt 5099 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5100 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5101 
    args = getStatusDistributionOfOrders_args()
5102 
    args.startDate = startDate
5103 
    args.endDate = endDate
5104 
    args.write(self._oprot)
5105 
    self._oprot.writeMessageEnd()
5106 
    self._oprot.trans.flush()
5107 
 
5108 
  def recv_getStatusDistributionOfOrders(self, ):
5109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5110 
    if mtype == TMessageType.EXCEPTION:
5111 
      x = TApplicationException()
5112 
      x.read(self._iprot)
5113 
      self._iprot.readMessageEnd()
5114 
      raise x
5115 
    result = getStatusDistributionOfOrders_result()
5116 
    result.read(self._iprot)
5117 
    self._iprot.readMessageEnd()
5118 
    if result.success is not None:
5119 
      return result.success
5120 
    if result.ex is not None:
5121 
      raise result.ex
5122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5123 
 
5067 varun.gupt 5124 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5125 
    """
5126 
    Parameters:
5127 
     - status
5128 
     - startDatetime
5129 
     - endDatetime
5130 
    """
5131 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5132 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5133 
 
5067 varun.gupt 5134 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5135 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5136 
    args = getOrderIdsForStatus_args()
5137 
    args.status = status
5138 
    args.startDatetime = startDatetime
5139 
    args.endDatetime = endDatetime
5140 
    args.write(self._oprot)
5141 
    self._oprot.writeMessageEnd()
5142 
    self._oprot.trans.flush()
5143 
 
5144 
  def recv_getOrderIdsForStatus(self, ):
5145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5146 
    if mtype == TMessageType.EXCEPTION:
5147 
      x = TApplicationException()
5148 
      x.read(self._iprot)
5149 
      self._iprot.readMessageEnd()
5150 
      raise x
5151 
    result = getOrderIdsForStatus_result()
5152 
    result.read(self._iprot)
5153 
    self._iprot.readMessageEnd()
5154 
    if result.success is not None:
5155 
      return result.success
5156 
    if result.ex is not None:
5157 
      raise result.ex
5158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5159 
 
5348 anupam.sin 5160 
  def updateCODAgent(self, agent, orderId):
5161 
    """
5162 
    Updates the agent who handled the COD verification call
5163 
 
5164 
    Parameters:
5165 
     - agent
5166 
     - orderId
5167 
    """
5168 
    self.send_updateCODAgent(agent, orderId)
5169 
    self.recv_updateCODAgent()
5170 
 
5171 
  def send_updateCODAgent(self, agent, orderId):
5172 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5173 
    args = updateCODAgent_args()
5174 
    args.agent = agent
5175 
    args.orderId = orderId
5176 
    args.write(self._oprot)
5177 
    self._oprot.writeMessageEnd()
5178 
    self._oprot.trans.flush()
5179 
 
5180 
  def recv_updateCODAgent(self, ):
5181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5182 
    if mtype == TMessageType.EXCEPTION:
5183 
      x = TApplicationException()
5184 
      x.read(self._iprot)
5185 
      self._iprot.readMessageEnd()
5186 
      raise x
5187 
    result = updateCODAgent_result()
5188 
    result.read(self._iprot)
5189 
    self._iprot.readMessageEnd()
5190 
    if result.ex is not None:
5191 
      raise result.ex
5192 
    return
5193 
 
5099 varun.gupt 5194 
  def updateOrderAsPaidToVendor(self, orderId):
5195 
    """
5196 
    Parameters:
5197 
     - orderId
5198 
    """
5199 
    self.send_updateOrderAsPaidToVendor(orderId)
5200 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5201 
 
5099 varun.gupt 5202 
  def send_updateOrderAsPaidToVendor(self, orderId):
5203 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5204 
    args = updateOrderAsPaidToVendor_args()
5205 
    args.orderId = orderId
5206 
    args.write(self._oprot)
5207 
    self._oprot.writeMessageEnd()
5208 
    self._oprot.trans.flush()
5209 
 
5210 
  def recv_updateOrderAsPaidToVendor(self, ):
5211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5212 
    if mtype == TMessageType.EXCEPTION:
5213 
      x = TApplicationException()
5214 
      x.read(self._iprot)
5215 
      self._iprot.readMessageEnd()
5216 
      raise x
5217 
    result = updateOrderAsPaidToVendor_result()
5218 
    result.read(self._iprot)
5219 
    self._iprot.readMessageEnd()
5220 
    if result.ex is not None:
5221 
      raise result.ex
5222 
    return
5223 
 
5386 phani.kuma 5224 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5225 
    """
5226 
    Parameters:
5227 
     - orderId
5228 
    """
5229 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5230 
    self.recv_updateOrderOnlyAsPaidToVendor()
5231 
 
5232 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5233 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5234 
    args = updateOrderOnlyAsPaidToVendor_args()
5235 
    args.orderId = orderId
5236 
    args.write(self._oprot)
5237 
    self._oprot.writeMessageEnd()
5238 
    self._oprot.trans.flush()
5239 
 
5240 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5242 
    if mtype == TMessageType.EXCEPTION:
5243 
      x = TApplicationException()
5244 
      x.read(self._iprot)
5245 
      self._iprot.readMessageEnd()
5246 
      raise x
5247 
    result = updateOrderOnlyAsPaidToVendor_result()
5248 
    result.read(self._iprot)
5249 
    self._iprot.readMessageEnd()
5250 
    if result.ex is not None:
5251 
      raise result.ex
5252 
    return
5253 
 
5208 varun.gupt 5254 
  def getRefundedOrdersMarkedPaid(self, ):
5255 
    self.send_getRefundedOrdersMarkedPaid()
5256 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5257 
 
5208 varun.gupt 5258 
  def send_getRefundedOrdersMarkedPaid(self, ):
5259 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5260 
    args = getRefundedOrdersMarkedPaid_args()
5261 
    args.write(self._oprot)
5262 
    self._oprot.writeMessageEnd()
5263 
    self._oprot.trans.flush()
5264 
 
5265 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5267 
    if mtype == TMessageType.EXCEPTION:
5268 
      x = TApplicationException()
5269 
      x.read(self._iprot)
5270 
      self._iprot.readMessageEnd()
5271 
      raise x
5272 
    result = getRefundedOrdersMarkedPaid_result()
5273 
    result.read(self._iprot)
5274 
    self._iprot.readMessageEnd()
5275 
    if result.success is not None:
5276 
      return result.success
5277 
    if result.ex is not None:
5278 
      raise result.ex
5279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5280 
 
5447 anupam.sin 5281 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5282 
    """
5283 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5284 
 
5447 anupam.sin 5285 
 
5286 
    Parameters:
5287 
     - minOrderId
5288 
     - maxOrderId
5289 
    """
5290 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5291 
    return self.recv_getAllVerificationAgents()
5292 
 
5293 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5294 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5295 
    args = getAllVerificationAgents_args()
5296 
    args.minOrderId = minOrderId
5297 
    args.maxOrderId = maxOrderId
5298 
    args.write(self._oprot)
5299 
    self._oprot.writeMessageEnd()
5300 
    self._oprot.trans.flush()
5301 
 
5302 
  def recv_getAllVerificationAgents(self, ):
5303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5304 
    if mtype == TMessageType.EXCEPTION:
5305 
      x = TApplicationException()
5306 
      x.read(self._iprot)
5307 
      self._iprot.readMessageEnd()
5308 
      raise x
5309 
    result = getAllVerificationAgents_result()
5310 
    result.read(self._iprot)
5311 
    self._iprot.readMessageEnd()
5312 
    if result.success is not None:
5313 
      return result.success
5314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5315 
 
5527 anupam.sin 5316 
  def getAllAttributesForOrderId(self, orderId):
5317 
    """
5318 
    gets all attributes for a given orderId
5447 anupam.sin 5319 
 
5527 anupam.sin 5320 
    Parameters:
5321 
     - orderId
5322 
    """
5323 
    self.send_getAllAttributesForOrderId(orderId)
5324 
    return self.recv_getAllAttributesForOrderId()
5325 
 
5326 
  def send_getAllAttributesForOrderId(self, orderId):
5327 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5328 
    args = getAllAttributesForOrderId_args()
5329 
    args.orderId = orderId
5330 
    args.write(self._oprot)
5331 
    self._oprot.writeMessageEnd()
5332 
    self._oprot.trans.flush()
5333 
 
5334 
  def recv_getAllAttributesForOrderId(self, ):
5335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5336 
    if mtype == TMessageType.EXCEPTION:
5337 
      x = TApplicationException()
5338 
      x.read(self._iprot)
5339 
      self._iprot.readMessageEnd()
5340 
      raise x
5341 
    result = getAllAttributesForOrderId_result()
5342 
    result.read(self._iprot)
5343 
    self._iprot.readMessageEnd()
5344 
    if result.success is not None:
5345 
      return result.success
5346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5347 
 
5348 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5349 
    """
5350 
    sets attributes for all orders in a transaction
5351 
 
5352 
    Parameters:
5353 
     - transactionId
5354 
     - attribute
5355 
    """
5356 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5357 
    self.recv_setOrderAttributeForTransaction()
5358 
 
5359 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5360 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5361 
    args = setOrderAttributeForTransaction_args()
5362 
    args.transactionId = transactionId
5363 
    args.attribute = attribute
5364 
    args.write(self._oprot)
5365 
    self._oprot.writeMessageEnd()
5366 
    self._oprot.trans.flush()
5367 
 
5368 
  def recv_setOrderAttributeForTransaction(self, ):
5369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5370 
    if mtype == TMessageType.EXCEPTION:
5371 
      x = TApplicationException()
5372 
      x.read(self._iprot)
5373 
      self._iprot.readMessageEnd()
5374 
      raise x
5375 
    result = setOrderAttributeForTransaction_result()
5376 
    result.read(self._iprot)
5377 
    self._iprot.readMessageEnd()
5378 
    return
5379 
 
5553 rajveer 5380 
  def getReceivePendingOrders(self, storeId):
5381 
    """
5382 
    Parameters:
5383 
     - storeId
5384 
    """
5385 
    self.send_getReceivePendingOrders(storeId)
5386 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5387 
 
5553 rajveer 5388 
  def send_getReceivePendingOrders(self, storeId):
5389 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5390 
    args = getReceivePendingOrders_args()
5391 
    args.storeId = storeId
5392 
    args.write(self._oprot)
5393 
    self._oprot.writeMessageEnd()
5394 
    self._oprot.trans.flush()
5395 
 
5396 
  def recv_getReceivePendingOrders(self, ):
5397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5398 
    if mtype == TMessageType.EXCEPTION:
5399 
      x = TApplicationException()
5400 
      x.read(self._iprot)
5401 
      self._iprot.readMessageEnd()
5402 
      raise x
5403 
    result = getReceivePendingOrders_result()
5404 
    result.read(self._iprot)
5405 
    self._iprot.readMessageEnd()
5406 
    if result.success is not None:
5407 
      return result.success
5408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5409 
 
5410 
  def getReceivedAtStoreOrders(self, storeId):
5411 
    """
5412 
    Parameters:
5413 
     - storeId
5414 
    """
5415 
    self.send_getReceivedAtStoreOrders(storeId)
5416 
    return self.recv_getReceivedAtStoreOrders()
5417 
 
5418 
  def send_getReceivedAtStoreOrders(self, storeId):
5419 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5420 
    args = getReceivedAtStoreOrders_args()
5421 
    args.storeId = storeId
5422 
    args.write(self._oprot)
5423 
    self._oprot.writeMessageEnd()
5424 
    self._oprot.trans.flush()
5425 
 
5426 
  def recv_getReceivedAtStoreOrders(self, ):
5427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5428 
    if mtype == TMessageType.EXCEPTION:
5429 
      x = TApplicationException()
5430 
      x.read(self._iprot)
5431 
      self._iprot.readMessageEnd()
5432 
      raise x
5433 
    result = getReceivedAtStoreOrders_result()
5434 
    result.read(self._iprot)
5435 
    self._iprot.readMessageEnd()
5436 
    if result.success is not None:
5437 
      return result.success
5438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5439 
 
5593 mandeep.dh 5440 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5441 
    """
5442 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5443 
    invoked while scanning IN of items.
5553 rajveer 5444 
 
5593 mandeep.dh 5445 
    Parameters:
5446 
     - itemId
5447 
     - quantity
5448 
     - fulfilmentWarehouseId
5449 
     - billingWarehouseId
5450 
    """
5451 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5452 
    self.recv_acceptOrderForItem()
5453 
 
5454 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5455 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5456 
    args = acceptOrderForItem_args()
5457 
    args.itemId = itemId
5458 
    args.quantity = quantity
5459 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5460 
    args.billingWarehouseId = billingWarehouseId
5461 
    args.write(self._oprot)
5462 
    self._oprot.writeMessageEnd()
5463 
    self._oprot.trans.flush()
5464 
 
5465 
  def recv_acceptOrderForItem(self, ):
5466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5467 
    if mtype == TMessageType.EXCEPTION:
5468 
      x = TApplicationException()
5469 
      x.read(self._iprot)
5470 
      self._iprot.readMessageEnd()
5471 
      raise x
5472 
    result = acceptOrderForItem_result()
5473 
    result.read(self._iprot)
5474 
    self._iprot.readMessageEnd()
5475 
    return
5476 
 
5477 
 
3376 rajveer 5478 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5479 
  def __init__(self, handler):
3376 rajveer 5480 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5481 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5482 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5483 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5484 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5485 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5486 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5487 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5488 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5489 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5490 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5491 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5492 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5493 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5494 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5495 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5496 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5497 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5498 
    self._processMap["createOrder"] = Processor.process_createOrder
5499 
    self._processMap["getOrder"] = Processor.process_getOrder
5500 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5501 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5502 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5503 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5504 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5505 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5506 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5507 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5508 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5509 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5510 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5511 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5512 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5513 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5514 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5515 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5516 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5517 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5518 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5519 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5520 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5521 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5522 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5523 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5524 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5525 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5526 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5527 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5528 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5529 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5530 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5531 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5532 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5533 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5534 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5535 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5536 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5537 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5538 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5539 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5540 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5541 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5542 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5543 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5544 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5545 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5546 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5547 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5548 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5549 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5550 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5551 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5552 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5553 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5554 
    self._processMap["changeItem"] = Processor.process_changeItem
5555 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5556 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5557 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5558 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5559 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5560 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5561 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5562 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5563 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5564 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5565 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5566 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5567 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5568 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5569 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5570 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5571 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5572 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5573 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5574 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5575 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5576 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5577 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5578 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5579 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5580 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5581 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5582 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5583 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5584 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5585 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5586 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5587 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5588 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5589 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5590 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5591 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5592 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5593 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5594 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5595 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5596 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5597 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5598 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5599 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5600 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5593 mandeep.dh 5601 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
94 ashish 5602 
 
5603 
  def process(self, iprot, oprot):
5604 
    (name, type, seqid) = iprot.readMessageBegin()
5605 
    if name not in self._processMap:
5606 
      iprot.skip(TType.STRUCT)
5607 
      iprot.readMessageEnd()
5608 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5609 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5610 
      x.write(oprot)
5611 
      oprot.writeMessageEnd()
5612 
      oprot.trans.flush()
5613 
      return
5614 
    else:
5615 
      self._processMap[name](self, seqid, iprot, oprot)
5616 
    return True
5617 
 
5618 
  def process_createTransaction(self, seqid, iprot, oprot):
5619 
    args = createTransaction_args()
5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
5622 
    result = createTransaction_result()
5623 
    try:
132 ashish 5624 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5625 
    except TransactionServiceException, ex:
5626 
      result.ex = ex
5627 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5628 
    result.write(oprot)
5629 
    oprot.writeMessageEnd()
5630 
    oprot.trans.flush()
5631 
 
5632 
  def process_getTransaction(self, seqid, iprot, oprot):
5633 
    args = getTransaction_args()
5634 
    args.read(iprot)
5635 
    iprot.readMessageEnd()
5636 
    result = getTransaction_result()
5637 
    try:
5638 
      result.success = self._handler.getTransaction(args.id)
5639 
    except TransactionServiceException, ex:
5640 
      result.ex = ex
5641 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5642 
    result.write(oprot)
5643 
    oprot.writeMessageEnd()
5644 
    oprot.trans.flush()
5645 
 
5646 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5647 
    args = getTransactionsForCustomer_args()
5648 
    args.read(iprot)
5649 
    iprot.readMessageEnd()
5650 
    result = getTransactionsForCustomer_result()
5651 
    try:
5652 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5653 
    except TransactionServiceException, ex:
5654 
      result.ex = ex
5655 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5656 
    result.write(oprot)
5657 
    oprot.writeMessageEnd()
5658 
    oprot.trans.flush()
5659 
 
132 ashish 5660 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5661 
    args = getTransactionsForShoppingCartId_args()
5662 
    args.read(iprot)
5663 
    iprot.readMessageEnd()
5664 
    result = getTransactionsForShoppingCartId_result()
5665 
    try:
5666 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5667 
    except TransactionServiceException, ex:
5668 
      result.ex = ex
5669 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5670 
    result.write(oprot)
5671 
    oprot.writeMessageEnd()
5672 
    oprot.trans.flush()
5673 
 
94 ashish 5674 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5675 
    args = getTransactionStatus_args()
5676 
    args.read(iprot)
5677 
    iprot.readMessageEnd()
5678 
    result = getTransactionStatus_result()
5679 
    try:
5680 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5681 
    except TransactionServiceException, ex:
5682 
      result.ex = ex
5683 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5684 
    result.write(oprot)
5685 
    oprot.writeMessageEnd()
5686 
    oprot.trans.flush()
5687 
 
5688 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5689 
    args = changeTransactionStatus_args()
5690 
    args.read(iprot)
5691 
    iprot.readMessageEnd()
5692 
    result = changeTransactionStatus_result()
5693 
    try:
5527 anupam.sin 5694 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5695 
    except TransactionServiceException, ex:
5696 
      result.ex = ex
5697 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5698 
    result.write(oprot)
5699 
    oprot.writeMessageEnd()
5700 
    oprot.trans.flush()
5701 
 
1398 varun.gupt 5702 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5703 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5704 
    args.read(iprot)
5705 
    iprot.readMessageEnd()
1398 varun.gupt 5706 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5707 
    try:
1398 varun.gupt 5708 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5709 
    except TransactionServiceException, ex:
5710 
      result.ex = ex
1398 varun.gupt 5711 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5712 
    result.write(oprot)
5713 
    oprot.writeMessageEnd()
5714 
    oprot.trans.flush()
5715 
 
483 rajveer 5716 
  def process_getAllOrders(self, seqid, iprot, oprot):
5717 
    args = getAllOrders_args()
94 ashish 5718 
    args.read(iprot)
5719 
    iprot.readMessageEnd()
483 rajveer 5720 
    result = getAllOrders_result()
94 ashish 5721 
    try:
4801 anupam.sin 5722 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5723 
    except TransactionServiceException, ex:
5724 
      result.ex = ex
483 rajveer 5725 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5726 
    result.write(oprot)
5727 
    oprot.writeMessageEnd()
5728 
    oprot.trans.flush()
5729 
 
4133 chandransh 5730 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5731 
    args = getOrdersInBatch_args()
5732 
    args.read(iprot)
5733 
    iprot.readMessageEnd()
5734 
    result = getOrdersInBatch_result()
5735 
    try:
5736 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5737 
    except TransactionServiceException, ex:
5738 
      result.ex = ex
5739 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5740 
    result.write(oprot)
5741 
    oprot.writeMessageEnd()
5742 
    oprot.trans.flush()
5743 
 
5744 
  def process_getOrderCount(self, seqid, iprot, oprot):
5745 
    args = getOrderCount_args()
5746 
    args.read(iprot)
5747 
    iprot.readMessageEnd()
5748 
    result = getOrderCount_result()
5749 
    try:
5750 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5751 
    except TransactionServiceException, ex:
5752 
      result.ex = ex
5753 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5754 
    result.write(oprot)
5755 
    oprot.writeMessageEnd()
5756 
    oprot.trans.flush()
5757 
 
999 varun.gupt 5758 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5759 
    args = getOrdersByBillingDate_args()
5760 
    args.read(iprot)
5761 
    iprot.readMessageEnd()
5762 
    result = getOrdersByBillingDate_result()
5763 
    try:
5764 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5765 
    except TransactionServiceException, ex:
5766 
      result.ex = ex
5767 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5768 
    result.write(oprot)
5769 
    oprot.writeMessageEnd()
5770 
    oprot.trans.flush()
5771 
 
3427 chandransh 5772 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5773 
    args = getOrdersByShippingDate_args()
5774 
    args.read(iprot)
5775 
    iprot.readMessageEnd()
5776 
    result = getOrdersByShippingDate_result()
5777 
    try:
3451 chandransh 5778 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5779 
    except TransactionServiceException, ex:
5780 
      result.ex = ex
5781 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5782 
    result.write(oprot)
5783 
    oprot.writeMessageEnd()
5784 
    oprot.trans.flush()
5785 
 
1382 varun.gupt 5786 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5787 
    args = getReturnableOrdersForCustomer_args()
5788 
    args.read(iprot)
5789 
    iprot.readMessageEnd()
5790 
    result = getReturnableOrdersForCustomer_result()
5791 
    try:
5792 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5793 
    except TransactionServiceException, ex:
5794 
      result.ex = ex
5795 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5796 
    result.write(oprot)
5797 
    oprot.writeMessageEnd()
5798 
    oprot.trans.flush()
5799 
 
5800 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5801 
    args = getCancellableOrdersForCustomer_args()
5802 
    args.read(iprot)
5803 
    iprot.readMessageEnd()
5804 
    result = getCancellableOrdersForCustomer_result()
5805 
    try:
5806 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5807 
    except TransactionServiceException, ex:
5808 
      result.ex = ex
5809 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5810 
    result.write(oprot)
5811 
    oprot.writeMessageEnd()
5812 
    oprot.trans.flush()
5813 
 
483 rajveer 5814 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5815 
    args = changeOrderStatus_args()
94 ashish 5816 
    args.read(iprot)
5817 
    iprot.readMessageEnd()
483 rajveer 5818 
    result = changeOrderStatus_result()
94 ashish 5819 
    try:
483 rajveer 5820 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5821 
    except TransactionServiceException, ex:
5822 
      result.ex = ex
483 rajveer 5823 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5824 
    result.write(oprot)
5825 
    oprot.writeMessageEnd()
5826 
    oprot.trans.flush()
5827 
 
483 rajveer 5828 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5829 
    args = getOrdersForTransaction_args()
94 ashish 5830 
    args.read(iprot)
5831 
    iprot.readMessageEnd()
483 rajveer 5832 
    result = getOrdersForTransaction_result()
94 ashish 5833 
    try:
1528 ankur.sing 5834 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5835 
    except TransactionServiceException, ex:
5836 
      result.ex = ex
483 rajveer 5837 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5838 
    result.write(oprot)
5839 
    oprot.writeMessageEnd()
5840 
    oprot.trans.flush()
5841 
 
483 rajveer 5842 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5843 
    args = getOrdersForCustomer_args()
94 ashish 5844 
    args.read(iprot)
5845 
    iprot.readMessageEnd()
483 rajveer 5846 
    result = getOrdersForCustomer_result()
94 ashish 5847 
    try:
3014 chandransh 5848 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5849 
    except TransactionServiceException, ex:
5850 
      result.ex = ex
483 rajveer 5851 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5852 
    result.write(oprot)
5853 
    oprot.writeMessageEnd()
5854 
    oprot.trans.flush()
5855 
 
483 rajveer 5856 
  def process_createOrder(self, seqid, iprot, oprot):
5857 
    args = createOrder_args()
94 ashish 5858 
    args.read(iprot)
5859 
    iprot.readMessageEnd()
483 rajveer 5860 
    result = createOrder_result()
94 ashish 5861 
    try:
483 rajveer 5862 
      result.success = self._handler.createOrder(args.order)
94 ashish 5863 
    except TransactionServiceException, ex:
5864 
      result.ex = ex
483 rajveer 5865 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5866 
    result.write(oprot)
5867 
    oprot.writeMessageEnd()
5868 
    oprot.trans.flush()
5869 
 
483 rajveer 5870 
  def process_getOrder(self, seqid, iprot, oprot):
5871 
    args = getOrder_args()
94 ashish 5872 
    args.read(iprot)
5873 
    iprot.readMessageEnd()
483 rajveer 5874 
    result = getOrder_result()
94 ashish 5875 
    try:
483 rajveer 5876 
      result.success = self._handler.getOrder(args.id)
94 ashish 5877 
    except TransactionServiceException, ex:
5878 
      result.ex = ex
483 rajveer 5879 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
483 rajveer 5884 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5885 
    args = getLineItemsForOrder_args()
94 ashish 5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
483 rajveer 5888 
    result = getLineItemsForOrder_result()
94 ashish 5889 
    try:
483 rajveer 5890 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5891 
    except TransactionServiceException, ex:
5892 
      result.ex = ex
483 rajveer 5893 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5894 
    result.write(oprot)
5895 
    oprot.writeMessageEnd()
5896 
    oprot.trans.flush()
5897 
 
4999 phani.kuma 5898 
  def process_getOrderList(self, seqid, iprot, oprot):
5899 
    args = getOrderList_args()
5900 
    args.read(iprot)
5901 
    iprot.readMessageEnd()
5902 
    result = getOrderList_result()
5903 
    result.success = self._handler.getOrderList(args.order_ids)
5904 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5905 
    result.write(oprot)
5906 
    oprot.writeMessageEnd()
5907 
    oprot.trans.flush()
5908 
 
5386 phani.kuma 5909 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5910 
    args = getOrderListForVendor_args()
5911 
    args.read(iprot)
5912 
    iprot.readMessageEnd()
5913 
    result = getOrderListForVendor_result()
5914 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5915 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5916 
    result.write(oprot)
5917 
    oprot.writeMessageEnd()
5918 
    oprot.trans.flush()
5919 
 
1528 ankur.sing 5920 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5921 
    args = getOrderForCustomer_args()
5922 
    args.read(iprot)
5923 
    iprot.readMessageEnd()
5924 
    result = getOrderForCustomer_result()
5925 
    try:
5926 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5927 
    except TransactionServiceException, ex:
5928 
      result.ex = ex
5929 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5930 
    result.write(oprot)
5931 
    oprot.writeMessageEnd()
5932 
    oprot.trans.flush()
5933 
 
3064 chandransh 5934 
  def process_getAlerts(self, seqid, iprot, oprot):
5935 
    args = getAlerts_args()
5936 
    args.read(iprot)
5937 
    iprot.readMessageEnd()
5938 
    result = getAlerts_result()
4444 rajveer 5939 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5940 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5941 
    result.write(oprot)
5942 
    oprot.writeMessageEnd()
5943 
    oprot.trans.flush()
5944 
 
4394 rajveer 5945 
  def process_addAlert(self, seqid, iprot, oprot):
5946 
    args = addAlert_args()
3064 chandransh 5947 
    args.read(iprot)
5948 
    iprot.readMessageEnd()
4394 rajveer 5949 
    result = addAlert_result()
4444 rajveer 5950 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5951 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5952 
    result.write(oprot)
5953 
    oprot.writeMessageEnd()
5954 
    oprot.trans.flush()
5955 
 
4444 rajveer 5956 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5957 
    args = markAlertsAsSeen_args()
5958 
    args.read(iprot)
5959 
    iprot.readMessageEnd()
5960 
    result = markAlertsAsSeen_result()
5961 
    self._handler.markAlertsAsSeen(args.warehouseId)
5962 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5963 
    result.write(oprot)
5964 
    oprot.writeMessageEnd()
5965 
    oprot.trans.flush()
5966 
 
3064 chandransh 5967 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5968 
    args = getValidOrderCount_args()
5969 
    args.read(iprot)
5970 
    iprot.readMessageEnd()
5971 
    result = getValidOrderCount_result()
5972 
    result.success = self._handler.getValidOrderCount()
5973 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5974 
    result.write(oprot)
5975 
    oprot.writeMessageEnd()
5976 
    oprot.trans.flush()
5977 
 
5978 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5979 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5980 
    args.read(iprot)
5981 
    iprot.readMessageEnd()
5982 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5983 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5984 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5985 
    result.write(oprot)
5986 
    oprot.writeMessageEnd()
5987 
    oprot.trans.flush()
5988 
 
5989 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5990 
    args = getValidOrdersAmountRange_args()
5991 
    args.read(iprot)
5992 
    iprot.readMessageEnd()
5993 
    result = getValidOrdersAmountRange_result()
5994 
    result.success = self._handler.getValidOrdersAmountRange()
5995 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5996 
    result.write(oprot)
5997 
    oprot.writeMessageEnd()
5998 
    oprot.trans.flush()
5999 
 
6000 
  def process_getValidOrders(self, seqid, iprot, oprot):
6001 
    args = getValidOrders_args()
6002 
    args.read(iprot)
6003 
    iprot.readMessageEnd()
6004 
    result = getValidOrders_result()
6005 
    result.success = self._handler.getValidOrders(args.limit)
6006 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
6010 
 
1220 chandransh 6011 
  def process_batchOrders(self, seqid, iprot, oprot):
6012 
    args = batchOrders_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = batchOrders_result()
6016 
    try:
6017 
      result.success = self._handler.batchOrders(args.warehouseId)
6018 
    except TransactionServiceException, ex:
6019 
      result.ex = ex
6020 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
6024 
 
1208 chandransh 6025 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6026 
    args = markOrderAsOutOfStock_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = markOrderAsOutOfStock_result()
6030 
    try:
6031 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6032 
    except TransactionServiceException, ex:
6033 
      result.ex = ex
6034 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6035 
    result.write(oprot)
6036 
    oprot.writeMessageEnd()
6037 
    oprot.trans.flush()
6038 
 
3064 chandransh 6039 
  def process_verifyOrder(self, seqid, iprot, oprot):
6040 
    args = verifyOrder_args()
759 chandransh 6041 
    args.read(iprot)
6042 
    iprot.readMessageEnd()
3064 chandransh 6043 
    result = verifyOrder_result()
759 chandransh 6044 
    try:
3064 chandransh 6045 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6046 
    except TransactionServiceException, ex:
6047 
      result.ex = ex
3064 chandransh 6048 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6049 
    result.write(oprot)
6050 
    oprot.writeMessageEnd()
6051 
    oprot.trans.flush()
6052 
 
3064 chandransh 6053 
  def process_acceptOrder(self, seqid, iprot, oprot):
6054 
    args = acceptOrder_args()
1113 chandransh 6055 
    args.read(iprot)
6056 
    iprot.readMessageEnd()
3064 chandransh 6057 
    result = acceptOrder_result()
1113 chandransh 6058 
    try:
3064 chandransh 6059 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6060 
    except TransactionServiceException, ex:
6061 
      result.ex = ex
3064 chandransh 6062 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6063 
    result.write(oprot)
6064 
    oprot.writeMessageEnd()
6065 
    oprot.trans.flush()
6066 
 
3064 chandransh 6067 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6068 
    args = addBillingDetails_args()
1135 chandransh 6069 
    args.read(iprot)
6070 
    iprot.readMessageEnd()
3064 chandransh 6071 
    result = addBillingDetails_result()
1135 chandransh 6072 
    try:
5110 mandeep.dh 6073 
      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 6074 
    except TransactionServiceException, ex:
6075 
      result.ex = ex
3064 chandransh 6076 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6077 
    result.write(oprot)
6078 
    oprot.writeMessageEnd()
6079 
    oprot.trans.flush()
6080 
 
4579 rajveer 6081 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6082 
    args = addInvoiceNumber_args()
6083 
    args.read(iprot)
6084 
    iprot.readMessageEnd()
6085 
    result = addInvoiceNumber_result()
6086 
    try:
4763 rajveer 6087 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6088 
    except TransactionServiceException, ex:
6089 
      result.ex = ex
6090 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6091 
    result.write(oprot)
6092 
    oprot.writeMessageEnd()
6093 
    oprot.trans.flush()
6094 
 
4410 rajveer 6095 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6096 
    args = markOrdersAsShippedFromWarehouse_args()
6097 
    args.read(iprot)
6098 
    iprot.readMessageEnd()
6099 
    result = markOrdersAsShippedFromWarehouse_result()
6100 
    try:
4789 rajveer 6101 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6102 
    except TransactionServiceException, ex:
6103 
      result.ex = ex
6104 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6105 
    result.write(oprot)
6106 
    oprot.writeMessageEnd()
6107 
    oprot.trans.flush()
6108 
 
3064 chandransh 6109 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6110 
    args = markOrdersAsPickedUp_args()
304 ashish 6111 
    args.read(iprot)
6112 
    iprot.readMessageEnd()
3064 chandransh 6113 
    result = markOrdersAsPickedUp_result()
6114 
    try:
4910 phani.kuma 6115 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6116 
    except TransactionServiceException, ex:
6117 
      result.ex = ex
6118 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6119 
    result.write(oprot)
6120 
    oprot.writeMessageEnd()
6121 
    oprot.trans.flush()
94 ashish 6122 
 
4910 phani.kuma 6123 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6124 
    args = getOrdersNotPickedUp_args()
6125 
    args.read(iprot)
6126 
    iprot.readMessageEnd()
6127 
    result = getOrdersNotPickedUp_result()
6128 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6129 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6130 
    result.write(oprot)
6131 
    oprot.writeMessageEnd()
6132 
    oprot.trans.flush()
6133 
 
3064 chandransh 6134 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6135 
    args = markOrdersAsDelivered_args()
304 ashish 6136 
    args.read(iprot)
6137 
    iprot.readMessageEnd()
3064 chandransh 6138 
    result = markOrdersAsDelivered_result()
6139 
    try:
6140 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6141 
    except TransactionServiceException, ex:
6142 
      result.ex = ex
6143 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6144 
    result.write(oprot)
6145 
    oprot.writeMessageEnd()
6146 
    oprot.trans.flush()
6147 
 
4910 phani.kuma 6148 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6149 
    args = markAsRTOrders_args()
1596 ankur.sing 6150 
    args.read(iprot)
6151 
    iprot.readMessageEnd()
4910 phani.kuma 6152 
    result = markAsRTOrders_result()
3064 chandransh 6153 
    try:
4910 phani.kuma 6154 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6155 
    except TransactionServiceException, ex:
6156 
      result.ex = ex
4910 phani.kuma 6157 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6158 
    result.write(oprot)
6159 
    oprot.writeMessageEnd()
6160 
    oprot.trans.flush()
304 ashish 6161 
 
4910 phani.kuma 6162 
  def process_getRTOrders(self, seqid, iprot, oprot):
6163 
    args = getRTOrders_args()
6164 
    args.read(iprot)
6165 
    iprot.readMessageEnd()
6166 
    result = getRTOrders_result()
6167 
    result.success = self._handler.getRTOrders(args.providerId)
6168 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6169 
    result.write(oprot)
6170 
    oprot.writeMessageEnd()
6171 
    oprot.trans.flush()
6172 
 
3064 chandransh 6173 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6174 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6175 
    args.read(iprot)
6176 
    iprot.readMessageEnd()
3064 chandransh 6177 
    result = updateNonDeliveryReason_result()
6178 
    try:
4910 phani.kuma 6179 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6180 
    except TransactionServiceException, ex:
6181 
      result.ex = ex
6182 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
1596 ankur.sing 6186 
 
4910 phani.kuma 6187 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6188 
    args = getNonDeliveredOrdersbyCourier_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = getNonDeliveredOrdersbyCourier_result()
6192 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6193 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6194 
    result.write(oprot)
6195 
    oprot.writeMessageEnd()
6196 
    oprot.trans.flush()
6197 
 
6198 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6199 
    args = markOrdersAsLocalConnected_args()
6200 
    args.read(iprot)
6201 
    iprot.readMessageEnd()
6202 
    result = markOrdersAsLocalConnected_result()
6203 
    try:
6204 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6205 
    except TransactionServiceException, ex:
6206 
      result.ex = ex
6207 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6208 
    result.write(oprot)
6209 
    oprot.writeMessageEnd()
6210 
    oprot.trans.flush()
6211 
 
6212 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6213 
    args = getOrdersNotLocalConnected_args()
6214 
    args.read(iprot)
6215 
    iprot.readMessageEnd()
6216 
    result = getOrdersNotLocalConnected_result()
6217 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6218 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
6222 
 
6223 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6224 
    args = markOrdersAsDestinationCityReached_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = markOrdersAsDestinationCityReached_result()
6228 
    try:
6229 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6230 
    except TransactionServiceException, ex:
6231 
      result.ex = ex
6232 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6233 
    result.write(oprot)
6234 
    oprot.writeMessageEnd()
6235 
    oprot.trans.flush()
6236 
 
6237 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6238 
    args = markOrdersAsFirstDeliveryAttempted_args()
6239 
    args.read(iprot)
6240 
    iprot.readMessageEnd()
6241 
    result = markOrdersAsFirstDeliveryAttempted_result()
6242 
    try:
6243 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6244 
    except TransactionServiceException, ex:
6245 
      result.ex = ex
6246 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6247 
    result.write(oprot)
6248 
    oprot.writeMessageEnd()
6249 
    oprot.trans.flush()
6250 
 
3064 chandransh 6251 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6252 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6253 
    args.read(iprot)
6254 
    iprot.readMessageEnd()
3064 chandransh 6255 
    result = getUndeliveredOrders_result()
6256 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6257 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6258 
    result.write(oprot)
6259 
    oprot.writeMessageEnd()
6260 
    oprot.trans.flush()
6261 
 
4783 phani.kuma 6262 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6263 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6264 
    args.read(iprot)
6265 
    iprot.readMessageEnd()
6266 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6267 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6268 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
6272 
 
2536 chandransh 6273 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6274 
    args = toggleDOAFlag_args()
6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
6277 
    result = toggleDOAFlag_result()
6278 
    try:
6279 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6280 
    except TransactionServiceException, ex:
6281 
      result.ex = ex
6282 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
1886 ankur.sing 6286 
 
4712 rajveer 6287 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6288 
    args = markOrderAsDelivered_args()
6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
6291 
    result = markOrderAsDelivered_result()
6292 
    try:
6293 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6294 
    except TransactionServiceException, ex:
6295 
      result.ex = ex
6296 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
6300 
 
5553 rajveer 6301 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6302 
    args = markOrderAsReceivedAtStore_args()
6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
6305 
    result = markOrderAsReceivedAtStore_result()
6306 
    try:
6307 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6308 
    except TransactionServiceException, ex:
6309 
      result.ex = ex
6310 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
6314 
 
4454 rajveer 6315 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6316 
    args = markOrderDoaRequestReceived_args()
6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
6319 
    result = markOrderDoaRequestReceived_result()
6320 
    try:
6321 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6322 
    except TransactionServiceException, ex:
6323 
      result.ex = ex
6324 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6325 
    result.write(oprot)
6326 
    oprot.writeMessageEnd()
6327 
    oprot.trans.flush()
6328 
 
6329 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6330 
    args = markOrderDoaRequestAuthorized_args()
6331 
    args.read(iprot)
6332 
    iprot.readMessageEnd()
6333 
    result = markOrderDoaRequestAuthorized_result()
6334 
    try:
6335 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6336 
    except TransactionServiceException, ex:
6337 
      result.ex = ex
6338 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
6342 
 
4488 rajveer 6343 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6344 
    args = markOrderReturnRequestReceived_args()
6345 
    args.read(iprot)
6346 
    iprot.readMessageEnd()
6347 
    result = markOrderReturnRequestReceived_result()
6348 
    try:
6349 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6350 
    except TransactionServiceException, ex:
6351 
      result.ex = ex
6352 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6353 
    result.write(oprot)
6354 
    oprot.writeMessageEnd()
6355 
    oprot.trans.flush()
6356 
 
6357 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6358 
    args = markOrderReturnRequestAuthorized_args()
6359 
    args.read(iprot)
6360 
    iprot.readMessageEnd()
6361 
    result = markOrderReturnRequestAuthorized_result()
6362 
    try:
6363 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6364 
    except TransactionServiceException, ex:
6365 
      result.ex = ex
6366 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6367 
    result.write(oprot)
6368 
    oprot.writeMessageEnd()
6369 
    oprot.trans.flush()
6370 
 
2536 chandransh 6371 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6372 
    args = requestPickupNumber_args()
6373 
    args.read(iprot)
6374 
    iprot.readMessageEnd()
6375 
    result = requestPickupNumber_result()
6376 
    try:
4579 rajveer 6377 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6378 
    except TransactionServiceException, ex:
6379 
      result.ex = ex
6380 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6381 
    result.write(oprot)
6382 
    oprot.writeMessageEnd()
6383 
    oprot.trans.flush()
6384 
 
6385 
  def process_authorizePickup(self, seqid, iprot, oprot):
6386 
    args = authorizePickup_args()
6387 
    args.read(iprot)
6388 
    iprot.readMessageEnd()
6389 
    result = authorizePickup_result()
6390 
    try:
4602 rajveer 6391 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6392 
    except TransactionServiceException, ex:
6393 
      result.ex = ex
6394 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6395 
    result.write(oprot)
6396 
    oprot.writeMessageEnd()
6397 
    oprot.trans.flush()
6398 
 
2764 chandransh 6399 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6400 
    args = markDoasAsPickedUp_args()
6401 
    args.read(iprot)
6402 
    iprot.readMessageEnd()
6403 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6404 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6405 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6406 
    result.write(oprot)
6407 
    oprot.writeMessageEnd()
6408 
    oprot.trans.flush()
6409 
 
4910 phani.kuma 6410 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6411 
    args = getDoasNotPickedUp_args()
6412 
    args.read(iprot)
6413 
    iprot.readMessageEnd()
6414 
    result = getDoasNotPickedUp_result()
6415 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6416 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6417 
    result.write(oprot)
6418 
    oprot.writeMessageEnd()
6419 
    oprot.trans.flush()
6420 
 
4741 phani.kuma 6421 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6422 
    args = markReturnOrdersAsPickedUp_args()
6423 
    args.read(iprot)
6424 
    iprot.readMessageEnd()
6425 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6426 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6427 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6428 
    result.write(oprot)
6429 
    oprot.writeMessageEnd()
6430 
    oprot.trans.flush()
6431 
 
4910 phani.kuma 6432 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6433 
    args = getReturnOrdersNotPickedUp_args()
6434 
    args.read(iprot)
6435 
    iprot.readMessageEnd()
6436 
    result = getReturnOrdersNotPickedUp_result()
6437 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6438 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
6442 
 
2616 chandransh 6443 
  def process_receiveReturn(self, seqid, iprot, oprot):
6444 
    args = receiveReturn_args()
2591 chandransh 6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
2616 chandransh 6447 
    result = receiveReturn_result()
2591 chandransh 6448 
    try:
4479 rajveer 6449 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6450 
    except TransactionServiceException, ex:
6451 
      result.ex = ex
2616 chandransh 6452 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6453 
    result.write(oprot)
6454 
    oprot.writeMessageEnd()
6455 
    oprot.trans.flush()
2536 chandransh 6456 
 
2591 chandransh 6457 
  def process_validateDoa(self, seqid, iprot, oprot):
6458 
    args = validateDoa_args()
6459 
    args.read(iprot)
6460 
    iprot.readMessageEnd()
6461 
    result = validateDoa_result()
6462 
    try:
6463 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6464 
    except TransactionServiceException, ex:
6465 
      result.ex = ex
6466 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6467 
    result.write(oprot)
6468 
    oprot.writeMessageEnd()
6469 
    oprot.trans.flush()
6470 
 
4495 rajveer 6471 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6472 
    args = validateReturnProduct_args()
6473 
    args.read(iprot)
6474 
    iprot.readMessageEnd()
6475 
    result = validateReturnProduct_result()
6476 
    try:
6477 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6478 
    except TransactionServiceException, ex:
6479 
      result.ex = ex
6480 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
6484 
 
2616 chandransh 6485 
  def process_reshipOrder(self, seqid, iprot, oprot):
6486 
    args = reshipOrder_args()
6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
6489 
    result = reshipOrder_result()
6490 
    try:
6491 
      result.success = self._handler.reshipOrder(args.orderId)
6492 
    except TransactionServiceException, ex:
6493 
      result.ex = ex
6494 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
2591 chandransh 6498 
 
2616 chandransh 6499 
  def process_refundOrder(self, seqid, iprot, oprot):
6500 
    args = refundOrder_args()
6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
6503 
    result = refundOrder_result()
6504 
    try:
3226 chandransh 6505 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6506 
    except TransactionServiceException, ex:
6507 
      result.ex = ex
6508 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6509 
    result.write(oprot)
6510 
    oprot.writeMessageEnd()
6511 
    oprot.trans.flush()
6512 
 
2690 chandransh 6513 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6514 
    args = getReturnOrders_args()
6515 
    args.read(iprot)
6516 
    iprot.readMessageEnd()
6517 
    result = getReturnOrders_result()
6518 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6519 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6520 
    result.write(oprot)
6521 
    oprot.writeMessageEnd()
6522 
    oprot.trans.flush()
2616 chandransh 6523 
 
5481 phani.kuma 6524 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6525 
    args = getAllReturnOrders_args()
6526 
    args.read(iprot)
6527 
    iprot.readMessageEnd()
6528 
    result = getAllReturnOrders_result()
6529 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6530 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
6534 
 
2700 chandransh 6535 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6536 
    args = getReturnOrder_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = getReturnOrder_result()
6540 
    try:
6541 
      result.success = self._handler.getReturnOrder(args.id)
6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
6548 
 
2690 chandransh 6549 
  def process_processReturn(self, seqid, iprot, oprot):
6550 
    args = processReturn_args()
6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
6553 
    result = processReturn_result()
6554 
    try:
6555 
      self._handler.processReturn(args.returnOrderId)
6556 
    except TransactionServiceException, ex:
6557 
      result.ex = ex
6558 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6559 
    result.write(oprot)
6560 
    oprot.writeMessageEnd()
6561 
    oprot.trans.flush()
6562 
 
3451 chandransh 6563 
  def process_updateWeight(self, seqid, iprot, oprot):
6564 
    args = updateWeight_args()
6565 
    args.read(iprot)
6566 
    iprot.readMessageEnd()
6567 
    result = updateWeight_result()
6568 
    try:
6569 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6570 
    except TransactionServiceException, ex:
6571 
      result.ex = ex
6572 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6573 
    result.write(oprot)
6574 
    oprot.writeMessageEnd()
6575 
    oprot.trans.flush()
2819 chandransh 6576 
 
3469 chandransh 6577 
  def process_changeItem(self, seqid, iprot, oprot):
6578 
    args = changeItem_args()
6579 
    args.read(iprot)
6580 
    iprot.readMessageEnd()
6581 
    result = changeItem_result()
6582 
    try:
6583 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6584 
    except TransactionServiceException, ex:
6585 
      result.ex = ex
6586 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6587 
    result.write(oprot)
6588 
    oprot.writeMessageEnd()
6589 
    oprot.trans.flush()
3451 chandransh 6590 
 
3469 chandransh 6591 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6592 
    args = shiftToWarehouse_args()
6593 
    args.read(iprot)
6594 
    iprot.readMessageEnd()
6595 
    result = shiftToWarehouse_result()
6596 
    try:
6597 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6598 
    except TransactionServiceException, ex:
6599 
      result.ex = ex
6600 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6601 
    result.write(oprot)
6602 
    oprot.writeMessageEnd()
6603 
    oprot.trans.flush()
6604 
 
3553 chandransh 6605 
  def process_addDelayReason(self, seqid, iprot, oprot):
6606 
    args = addDelayReason_args()
6607 
    args.read(iprot)
6608 
    iprot.readMessageEnd()
6609 
    result = addDelayReason_result()
6610 
    try:
4647 rajveer 6611 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6612 
    except TransactionServiceException, ex:
6613 
      result.ex = ex
6614 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6615 
    result.write(oprot)
6616 
    oprot.writeMessageEnd()
6617 
    oprot.trans.flush()
3469 chandransh 6618 
 
3956 chandransh 6619 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6620 
    args = reconcileCodCollection_args()
6621 
    args.read(iprot)
6622 
    iprot.readMessageEnd()
6623 
    result = reconcileCodCollection_result()
6624 
    try:
6625 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6626 
    except TransactionServiceException, ex:
6627 
      result.ex = ex
6628 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6629 
    result.write(oprot)
6630 
    oprot.writeMessageEnd()
6631 
    oprot.trans.flush()
3553 chandransh 6632 
 
4008 mandeep.dh 6633 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6634 
    args = getTransactionsRequiringExtraProcessing_args()
6635 
    args.read(iprot)
6636 
    iprot.readMessageEnd()
6637 
    result = getTransactionsRequiringExtraProcessing_result()
6638 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6639 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6640 
    result.write(oprot)
6641 
    oprot.writeMessageEnd()
6642 
    oprot.trans.flush()
3956 chandransh 6643 
 
4008 mandeep.dh 6644 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6645 
    args = markTransactionAsProcessed_args()
6646 
    args.read(iprot)
6647 
    iprot.readMessageEnd()
6648 
    result = markTransactionAsProcessed_result()
6649 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6650 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6651 
    result.write(oprot)
6652 
    oprot.writeMessageEnd()
6653 
    oprot.trans.flush()
6654 
 
4018 chandransh 6655 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6656 
    args = getItemWiseRiskyOrdersCount_args()
6657 
    args.read(iprot)
6658 
    iprot.readMessageEnd()
6659 
    result = getItemWiseRiskyOrdersCount_result()
6660 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6661 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6662 
    result.write(oprot)
6663 
    oprot.writeMessageEnd()
6664 
    oprot.trans.flush()
4008 mandeep.dh 6665 
 
4295 varun.gupt 6666 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6667 
    args = getOrdersForItemIds_args()
6668 
    args.read(iprot)
6669 
    iprot.readMessageEnd()
6670 
    result = getOrdersForItemIds_result()
6671 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6672 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6673 
    result.write(oprot)
6674 
    oprot.writeMessageEnd()
6675 
    oprot.trans.flush()
6676 
 
4247 rajveer 6677 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6678 
    args = markOrderCancellationRequestReceived_args()
6679 
    args.read(iprot)
6680 
    iprot.readMessageEnd()
6681 
    result = markOrderCancellationRequestReceived_result()
6682 
    try:
6683 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6684 
    except TransactionServiceException, ex:
6685 
      result.ex = ex
6686 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6687 
    result.write(oprot)
6688 
    oprot.writeMessageEnd()
6689 
    oprot.trans.flush()
4018 chandransh 6690 
 
4247 rajveer 6691 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6692 
    args = markOrderCancellationRequestConfirmed_args()
6693 
    args.read(iprot)
6694 
    iprot.readMessageEnd()
6695 
    result = markOrderCancellationRequestConfirmed_result()
6696 
    try:
6697 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6698 
    except TransactionServiceException, ex:
6699 
      result.ex = ex
6700 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6701 
    result.write(oprot)
6702 
    oprot.writeMessageEnd()
6703 
    oprot.trans.flush()
6704 
 
6705 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6706 
    args = markOrderCancellationRequestDenied_args()
6707 
    args.read(iprot)
6708 
    iprot.readMessageEnd()
6709 
    result = markOrderCancellationRequestDenied_result()
6710 
    try:
6711 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6712 
    except TransactionServiceException, ex:
6713 
      result.ex = ex
6714 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
6718 
 
4258 rajveer 6719 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6720 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
4258 rajveer 6723 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6724 
    try:
4258 rajveer 6725 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6726 
    except TransactionServiceException, ex:
6727 
      result.ex = ex
4258 rajveer 6728 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6729 
    result.write(oprot)
6730 
    oprot.writeMessageEnd()
6731 
    oprot.trans.flush()
6732 
 
4259 anupam.sin 6733 
  def process_refundTransaction(self, seqid, iprot, oprot):
6734 
    args = refundTransaction_args()
6735 
    args.read(iprot)
6736 
    iprot.readMessageEnd()
6737 
    result = refundTransaction_result()
6738 
    try:
6739 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6740 
    except TransactionServiceException, ex:
6741 
      result.ex = ex
6742 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6743 
    result.write(oprot)
6744 
    oprot.writeMessageEnd()
6745 
    oprot.trans.flush()
4247 rajveer 6746 
 
4324 mandeep.dh 6747 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6748 
    args = updateShipmentAddress_args()
6749 
    args.read(iprot)
6750 
    iprot.readMessageEnd()
6751 
    result = updateShipmentAddress_result()
6752 
    try:
6753 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6754 
    except TransactionServiceException, ex:
6755 
      result.ex = ex
6756 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6757 
    result.write(oprot)
6758 
    oprot.writeMessageEnd()
6759 
    oprot.trans.flush()
6760 
 
4285 rajveer 6761 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6762 
    args = acceptOrdersForItemId_args()
6763 
    args.read(iprot)
6764 
    iprot.readMessageEnd()
6765 
    result = acceptOrdersForItemId_result()
6766 
    try:
6767 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6768 
    except TransactionServiceException, ex:
6769 
      result.ex = ex
6770 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6771 
    result.write(oprot)
6772 
    oprot.writeMessageEnd()
6773 
    oprot.trans.flush()
4259 anupam.sin 6774 
 
4303 rajveer 6775 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6776 
    args = markOrdersAsPORaised_args()
6777 
    args.read(iprot)
6778 
    iprot.readMessageEnd()
6779 
    result = markOrdersAsPORaised_result()
6780 
    try:
4369 rajveer 6781 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6782 
    except TransactionServiceException, ex:
6783 
      result.ex = ex
6784 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6785 
    result.write(oprot)
6786 
    oprot.writeMessageEnd()
6787 
    oprot.trans.flush()
4285 rajveer 6788 
 
4303 rajveer 6789 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6790 
    args = markOrdersAsReversalInitiated_args()
6791 
    args.read(iprot)
6792 
    iprot.readMessageEnd()
6793 
    result = markOrdersAsReversalInitiated_result()
6794 
    try:
4369 rajveer 6795 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6796 
    except TransactionServiceException, ex:
6797 
      result.ex = ex
6798 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6799 
    result.write(oprot)
6800 
    oprot.writeMessageEnd()
6801 
    oprot.trans.flush()
6802 
 
6803 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6804 
    args = markOrdersAsNotAvailabke_args()
6805 
    args.read(iprot)
6806 
    iprot.readMessageEnd()
6807 
    result = markOrdersAsNotAvailabke_result()
6808 
    try:
4369 rajveer 6809 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6810 
    except TransactionServiceException, ex:
6811 
      result.ex = ex
6812 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6813 
    result.write(oprot)
6814 
    oprot.writeMessageEnd()
6815 
    oprot.trans.flush()
6816 
 
4369 rajveer 6817 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6818 
    args = markOrdersAsTimeout_args()
6819 
    args.read(iprot)
6820 
    iprot.readMessageEnd()
6821 
    result = markOrdersAsTimeout_result()
6822 
    try:
6823 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6824 
    except TransactionServiceException, ex:
6825 
      result.ex = ex
6826 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6827 
    result.write(oprot)
6828 
    oprot.writeMessageEnd()
6829 
    oprot.trans.flush()
4303 rajveer 6830 
 
4662 rajveer 6831 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6832 
    args = markOrderAsLostInTransit_args()
6833 
    args.read(iprot)
6834 
    iprot.readMessageEnd()
6835 
    result = markOrderAsLostInTransit_result()
6836 
    try:
6837 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6838 
    except TransactionServiceException, ex:
6839 
      result.ex = ex
6840 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6841 
    result.write(oprot)
6842 
    oprot.writeMessageEnd()
6843 
    oprot.trans.flush()
6844 
 
4386 anupam.sin 6845 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6846 
    args = getOrderForAwb_args()
6847 
    args.read(iprot)
6848 
    iprot.readMessageEnd()
6849 
    result = getOrderForAwb_result()
6850 
    try:
6851 
      result.success = self._handler.getOrderForAwb(args.awb)
6852 
    except TransactionServiceException, ex:
6853 
      result.ex = ex
6854 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6855 
    result.write(oprot)
6856 
    oprot.writeMessageEnd()
6857 
    oprot.trans.flush()
4369 rajveer 6858 
 
4506 phani.kuma 6859 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6860 
    args = getOrdersForProviderForStatus_args()
6861 
    args.read(iprot)
6862 
    iprot.readMessageEnd()
6863 
    result = getOrdersForProviderForStatus_result()
6864 
    try:
4910 phani.kuma 6865 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6866 
    except TransactionServiceException, ex:
6867 
      result.ex = ex
6868 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6869 
    result.write(oprot)
6870 
    oprot.writeMessageEnd()
6871 
    oprot.trans.flush()
4386 anupam.sin 6872 
 
4600 varun.gupt 6873 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6874 
    args = getBilledOrdersForVendor_args()
6875 
    args.read(iprot)
6876 
    iprot.readMessageEnd()
6877 
    result = getBilledOrdersForVendor_result()
6878 
    try:
6879 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6880 
    except TransactionServiceException, ex:
6881 
      result.ex = ex
6882 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
4506 phani.kuma 6886 
 
4607 rajveer 6887 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6888 
    args = getSlippedSippingDateOrders_args()
6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
6891 
    result = getSlippedSippingDateOrders_result()
6892 
    try:
6893 
      result.success = self._handler.getSlippedSippingDateOrders()
6894 
    except TransactionServiceException, ex:
6895 
      result.ex = ex
6896 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6897 
    result.write(oprot)
6898 
    oprot.writeMessageEnd()
6899 
    oprot.trans.flush()
6900 
 
4709 rajveer 6901 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6902 
    args = getCancelledOrders_args()
6903 
    args.read(iprot)
6904 
    iprot.readMessageEnd()
6905 
    result = getCancelledOrders_result()
6906 
    try:
6907 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6908 
    except TransactionServiceException, ex:
6909 
      result.ex = ex
6910 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
6914 
 
4600 varun.gupt 6915 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6916 
    args = saveBluedartSettlements_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = saveBluedartSettlements_result()
6920 
    try:
6921 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6922 
    except TransactionServiceException, ex:
6923 
      result.ex = ex
6924 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6925 
    result.write(oprot)
6926 
    oprot.writeMessageEnd()
6927 
    oprot.trans.flush()
6928 
 
6929 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6930 
    args = savePaymentSettlements_args()
6931 
    args.read(iprot)
6932 
    iprot.readMessageEnd()
6933 
    result = savePaymentSettlements_result()
6934 
    try:
4905 varun.gupt 6935 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6936 
    except TransactionServiceException, ex:
6937 
      result.ex = ex
6938 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6939 
    result.write(oprot)
6940 
    oprot.writeMessageEnd()
6941 
    oprot.trans.flush()
6942 
 
6943 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6944 
    args = saveEBSSettlementSummary_args()
6945 
    args.read(iprot)
6946 
    iprot.readMessageEnd()
6947 
    result = saveEBSSettlementSummary_result()
6948 
    try:
6949 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6950 
    except TransactionServiceException, ex:
6951 
      result.ex = ex
6952 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6953 
    result.write(oprot)
6954 
    oprot.writeMessageEnd()
6955 
    oprot.trans.flush()
6956 
 
5386 phani.kuma 6957 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6958 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6959 
    args.read(iprot)
6960 
    iprot.readMessageEnd()
5386 phani.kuma 6961 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6962 
    try:
5386 phani.kuma 6963 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6964 
    except TransactionServiceException, ex:
6965 
      result.ex = ex
5386 phani.kuma 6966 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6967 
    result.write(oprot)
6968 
    oprot.writeMessageEnd()
6969 
    oprot.trans.flush()
6970 
 
5386 phani.kuma 6971 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6972 
    args = getSettlementForCod_args()
6973 
    args.read(iprot)
6974 
    iprot.readMessageEnd()
6975 
    result = getSettlementForCod_result()
6976 
    try:
6977 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6978 
    except TransactionServiceException, ex:
6979 
      result.ex = ex
6980 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6981 
    result.write(oprot)
6982 
    oprot.writeMessageEnd()
6983 
    oprot.trans.flush()
6984 
 
4600 varun.gupt 6985 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6986 
    args = getEBSSettlementSummaries_args()
6987 
    args.read(iprot)
6988 
    iprot.readMessageEnd()
6989 
    result = getEBSSettlementSummaries_result()
6990 
    try:
6991 
      result.success = self._handler.getEBSSettlementSummaries()
6992 
    except TransactionServiceException, ex:
6993 
      result.ex = ex
6994 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6995 
    result.write(oprot)
6996 
    oprot.writeMessageEnd()
6997 
    oprot.trans.flush()
6998 
 
6999 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7000 
    args = markEBSSettlementUploaded_args()
7001 
    args.read(iprot)
7002 
    iprot.readMessageEnd()
7003 
    result = markEBSSettlementUploaded_result()
7004 
    try:
7005 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7006 
    except TransactionServiceException, ex:
7007 
      result.ex = ex
7008 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7009 
    result.write(oprot)
7010 
    oprot.writeMessageEnd()
7011 
    oprot.trans.flush()
7012 
 
7013 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7014 
    args = getEBSSettlementDate_args()
7015 
    args.read(iprot)
7016 
    iprot.readMessageEnd()
7017 
    result = getEBSSettlementDate_result()
7018 
    try:
7019 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7020 
    except TransactionServiceException, ex:
7021 
      result.ex = ex
7022 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7023 
    result.write(oprot)
7024 
    oprot.writeMessageEnd()
7025 
    oprot.trans.flush()
7026 
 
4715 varun.gupt 7027 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7028 
    args = getSettlementsByDate_args()
7029 
    args.read(iprot)
7030 
    iprot.readMessageEnd()
7031 
    result = getSettlementsByDate_result()
7032 
    try:
7033 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7034 
    except TransactionServiceException, ex:
7035 
      result.ex = ex
7036 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7037 
    result.write(oprot)
7038 
    oprot.writeMessageEnd()
7039 
    oprot.trans.flush()
4600 varun.gupt 7040 
 
4715 varun.gupt 7041 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7042 
    args = getReshippedOrderIds_args()
7043 
    args.read(iprot)
7044 
    iprot.readMessageEnd()
7045 
    result = getReshippedOrderIds_result()
7046 
    try:
7047 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7048 
    except TransactionServiceException, ex:
7049 
      result.ex = ex
7050 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7051 
    result.write(oprot)
7052 
    oprot.writeMessageEnd()
7053 
    oprot.trans.flush()
7054 
 
5481 phani.kuma 7055 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7056 
    args = getBilledOrders_args()
4875 varun.gupt 7057 
    args.read(iprot)
7058 
    iprot.readMessageEnd()
5481 phani.kuma 7059 
    result = getBilledOrders_result()
4875 varun.gupt 7060 
    try:
5481 phani.kuma 7061 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7062 
    except TransactionServiceException, ex:
7063 
      result.ex = ex
5481 phani.kuma 7064 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7065 
    result.write(oprot)
7066 
    oprot.writeMessageEnd()
7067 
    oprot.trans.flush()
4757 mandeep.dh 7068 
 
5031 varun.gupt 7069 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7070 
    args = getStatusDistributionOfOrders_args()
7071 
    args.read(iprot)
7072 
    iprot.readMessageEnd()
7073 
    result = getStatusDistributionOfOrders_result()
7074 
    try:
7075 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7076 
    except TransactionServiceException, ex:
7077 
      result.ex = ex
7078 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7079 
    result.write(oprot)
7080 
    oprot.writeMessageEnd()
7081 
    oprot.trans.flush()
4875 varun.gupt 7082 
 
5067 varun.gupt 7083 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7084 
    args = getOrderIdsForStatus_args()
7085 
    args.read(iprot)
7086 
    iprot.readMessageEnd()
7087 
    result = getOrderIdsForStatus_result()
7088 
    try:
7089 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7090 
    except TransactionServiceException, ex:
7091 
      result.ex = ex
7092 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7093 
    result.write(oprot)
7094 
    oprot.writeMessageEnd()
7095 
    oprot.trans.flush()
5031 varun.gupt 7096 
 
5348 anupam.sin 7097 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7098 
    args = updateCODAgent_args()
7099 
    args.read(iprot)
7100 
    iprot.readMessageEnd()
7101 
    result = updateCODAgent_result()
7102 
    try:
7103 
      self._handler.updateCODAgent(args.agent, args.orderId)
7104 
    except TransactionServiceException, ex:
7105 
      result.ex = ex
7106 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7107 
    result.write(oprot)
7108 
    oprot.writeMessageEnd()
7109 
    oprot.trans.flush()
7110 
 
5099 varun.gupt 7111 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7112 
    args = updateOrderAsPaidToVendor_args()
7113 
    args.read(iprot)
7114 
    iprot.readMessageEnd()
7115 
    result = updateOrderAsPaidToVendor_result()
7116 
    try:
7117 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7118 
    except TransactionServiceException, ex:
7119 
      result.ex = ex
7120 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7121 
    result.write(oprot)
7122 
    oprot.writeMessageEnd()
7123 
    oprot.trans.flush()
5067 varun.gupt 7124 
 
5386 phani.kuma 7125 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7126 
    args = updateOrderOnlyAsPaidToVendor_args()
7127 
    args.read(iprot)
7128 
    iprot.readMessageEnd()
7129 
    result = updateOrderOnlyAsPaidToVendor_result()
7130 
    try:
7131 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7132 
    except TransactionServiceException, ex:
7133 
      result.ex = ex
7134 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
7138 
 
5208 varun.gupt 7139 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7140 
    args = getRefundedOrdersMarkedPaid_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = getRefundedOrdersMarkedPaid_result()
7144 
    try:
7145 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7146 
    except TransactionServiceException, ex:
7147 
      result.ex = ex
7148 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
5099 varun.gupt 7152 
 
5447 anupam.sin 7153 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7154 
    args = getAllVerificationAgents_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = getAllVerificationAgents_result()
7158 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7159 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
5208 varun.gupt 7163 
 
5527 anupam.sin 7164 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7165 
    args = getAllAttributesForOrderId_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getAllAttributesForOrderId_result()
7169 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7170 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
5447 anupam.sin 7174 
 
5527 anupam.sin 7175 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7176 
    args = setOrderAttributeForTransaction_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = setOrderAttributeForTransaction_result()
7180 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7181 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7182 
    result.write(oprot)
7183 
    oprot.writeMessageEnd()
7184 
    oprot.trans.flush()
7185 
 
5553 rajveer 7186 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7187 
    args = getReceivePendingOrders_args()
7188 
    args.read(iprot)
7189 
    iprot.readMessageEnd()
7190 
    result = getReceivePendingOrders_result()
7191 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7192 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7193 
    result.write(oprot)
7194 
    oprot.writeMessageEnd()
7195 
    oprot.trans.flush()
5527 anupam.sin 7196 
 
5553 rajveer 7197 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7198 
    args = getReceivedAtStoreOrders_args()
7199 
    args.read(iprot)
7200 
    iprot.readMessageEnd()
7201 
    result = getReceivedAtStoreOrders_result()
7202 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7203 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7204 
    result.write(oprot)
7205 
    oprot.writeMessageEnd()
7206 
    oprot.trans.flush()
7207 
 
5593 mandeep.dh 7208 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7209 
    args = acceptOrderForItem_args()
7210 
    args.read(iprot)
7211 
    iprot.readMessageEnd()
7212 
    result = acceptOrderForItem_result()
7213 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7214 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7215 
    result.write(oprot)
7216 
    oprot.writeMessageEnd()
7217 
    oprot.trans.flush()
5553 rajveer 7218 
 
5593 mandeep.dh 7219 
 
94 ashish 7220 
# HELPER FUNCTIONS AND STRUCTURES
7221 
 
7222 
class createTransaction_args:
7223 
  """
7224 
  Attributes:
7225 
   - transaction
7226 
  """
7227 
 
7228 
  thrift_spec = (
7229 
    None, # 0
7230 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7231 
  )
7232 
 
7233 
  def __init__(self, transaction=None,):
7234 
    self.transaction = transaction
7235 
 
7236 
  def read(self, iprot):
7237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7239 
      return
7240 
    iprot.readStructBegin()
7241 
    while True:
7242 
      (fname, ftype, fid) = iprot.readFieldBegin()
7243 
      if ftype == TType.STOP:
7244 
        break
7245 
      if fid == 1:
7246 
        if ftype == TType.STRUCT:
7247 
          self.transaction = Transaction()
7248 
          self.transaction.read(iprot)
7249 
        else:
7250 
          iprot.skip(ftype)
7251 
      else:
7252 
        iprot.skip(ftype)
7253 
      iprot.readFieldEnd()
7254 
    iprot.readStructEnd()
7255 
 
7256 
  def write(self, oprot):
7257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7259 
      return
7260 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7261 
    if self.transaction is not None:
94 ashish 7262 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7263 
      self.transaction.write(oprot)
7264 
      oprot.writeFieldEnd()
7265 
    oprot.writeFieldStop()
7266 
    oprot.writeStructEnd()
7267 
 
3431 rajveer 7268 
  def validate(self):
7269 
    return
7270 
 
7271 
 
94 ashish 7272 
  def __repr__(self):
7273 
    L = ['%s=%r' % (key, value)
7274 
      for key, value in self.__dict__.iteritems()]
7275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7276 
 
7277 
  def __eq__(self, other):
7278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7279 
 
7280 
  def __ne__(self, other):
7281 
    return not (self == other)
7282 
 
7283 
class createTransaction_result:
7284 
  """
7285 
  Attributes:
132 ashish 7286 
   - success
94 ashish 7287 
   - ex
7288 
  """
7289 
 
7290 
  thrift_spec = (
132 ashish 7291 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7293 
  )
7294 
 
132 ashish 7295 
  def __init__(self, success=None, ex=None,):
7296 
    self.success = success
94 ashish 7297 
    self.ex = ex
7298 
 
7299 
  def read(self, iprot):
7300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7302 
      return
7303 
    iprot.readStructBegin()
7304 
    while True:
7305 
      (fname, ftype, fid) = iprot.readFieldBegin()
7306 
      if ftype == TType.STOP:
7307 
        break
132 ashish 7308 
      if fid == 0:
7309 
        if ftype == TType.I64:
7310 
          self.success = iprot.readI64();
7311 
        else:
7312 
          iprot.skip(ftype)
7313 
      elif fid == 1:
94 ashish 7314 
        if ftype == TType.STRUCT:
7315 
          self.ex = TransactionServiceException()
7316 
          self.ex.read(iprot)
7317 
        else:
7318 
          iprot.skip(ftype)
7319 
      else:
7320 
        iprot.skip(ftype)
7321 
      iprot.readFieldEnd()
7322 
    iprot.readStructEnd()
7323 
 
7324 
  def write(self, oprot):
7325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7327 
      return
7328 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7329 
    if self.success is not None:
132 ashish 7330 
      oprot.writeFieldBegin('success', TType.I64, 0)
7331 
      oprot.writeI64(self.success)
7332 
      oprot.writeFieldEnd()
3431 rajveer 7333 
    if self.ex is not None:
94 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 
 
94 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 
 
7355 
class getTransaction_args:
7356 
  """
7357 
  Attributes:
7358 
   - id
7359 
  """
7360 
 
7361 
  thrift_spec = (
7362 
    None, # 0
7363 
    (1, TType.I64, 'id', None, None, ), # 1
7364 
  )
7365 
 
7366 
  def __init__(self, id=None,):
7367 
    self.id = id
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.id = 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('getTransaction_args')
3431 rajveer 7393 
    if self.id is not None:
94 ashish 7394 
      oprot.writeFieldBegin('id', TType.I64, 1)
7395 
      oprot.writeI64(self.id)
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 getTransaction_result:
7416 
  """
7417 
  Attributes:
7418 
   - success
7419 
   - ex
7420 
  """
7421 
 
7422 
  thrift_spec = (
7423 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), 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.STRUCT:
7442 
          self.success = Transaction()
7443 
          self.success.read(iprot)
7444 
        else:
7445 
          iprot.skip(ftype)
7446 
      elif fid == 1:
7447 
        if ftype == TType.STRUCT:
7448 
          self.ex = TransactionServiceException()
7449 
          self.ex.read(iprot)
7450 
        else:
7451 
          iprot.skip(ftype)
7452 
      else:
7453 
        iprot.skip(ftype)
7454 
      iprot.readFieldEnd()
7455 
    iprot.readStructEnd()
7456 
 
7457 
  def write(self, oprot):
7458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7460 
      return
7461 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7462 
    if self.success is not None:
94 ashish 7463 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7464 
      self.success.write(oprot)
7465 
      oprot.writeFieldEnd()
3431 rajveer 7466 
    if self.ex is not None:
94 ashish 7467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7468 
      self.ex.write(oprot)
7469 
      oprot.writeFieldEnd()
7470 
    oprot.writeFieldStop()
7471 
    oprot.writeStructEnd()
7472 
 
3431 rajveer 7473 
  def validate(self):
7474 
    return
7475 
 
7476 
 
94 ashish 7477 
  def __repr__(self):
7478 
    L = ['%s=%r' % (key, value)
7479 
      for key, value in self.__dict__.iteritems()]
7480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7481 
 
7482 
  def __eq__(self, other):
7483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7484 
 
7485 
  def __ne__(self, other):
7486 
    return not (self == other)
7487 
 
7488 
class getTransactionsForCustomer_args:
7489 
  """
7490 
  Attributes:
7491 
   - customerId
7492 
   - from_date
7493 
   - to_date
7494 
   - status
7495 
  """
7496 
 
7497 
  thrift_spec = (
7498 
    None, # 0
7499 
    (1, TType.I64, 'customerId', None, None, ), # 1
7500 
    (2, TType.I64, 'from_date', None, None, ), # 2
7501 
    (3, TType.I64, 'to_date', None, None, ), # 3
7502 
    (4, TType.I32, 'status', None, None, ), # 4
7503 
  )
7504 
 
7505 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7506 
    self.customerId = customerId
7507 
    self.from_date = from_date
7508 
    self.to_date = to_date
7509 
    self.status = status
7510 
 
7511 
  def read(self, iprot):
7512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7514 
      return
7515 
    iprot.readStructBegin()
7516 
    while True:
7517 
      (fname, ftype, fid) = iprot.readFieldBegin()
7518 
      if ftype == TType.STOP:
7519 
        break
7520 
      if fid == 1:
7521 
        if ftype == TType.I64:
7522 
          self.customerId = iprot.readI64();
7523 
        else:
7524 
          iprot.skip(ftype)
7525 
      elif fid == 2:
7526 
        if ftype == TType.I64:
7527 
          self.from_date = iprot.readI64();
7528 
        else:
7529 
          iprot.skip(ftype)
7530 
      elif fid == 3:
7531 
        if ftype == TType.I64:
7532 
          self.to_date = iprot.readI64();
7533 
        else:
7534 
          iprot.skip(ftype)
7535 
      elif fid == 4:
7536 
        if ftype == TType.I32:
7537 
          self.status = iprot.readI32();
7538 
        else:
7539 
          iprot.skip(ftype)
7540 
      else:
7541 
        iprot.skip(ftype)
7542 
      iprot.readFieldEnd()
7543 
    iprot.readStructEnd()
7544 
 
7545 
  def write(self, oprot):
7546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7548 
      return
7549 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7550 
    if self.customerId is not None:
94 ashish 7551 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7552 
      oprot.writeI64(self.customerId)
7553 
      oprot.writeFieldEnd()
3431 rajveer 7554 
    if self.from_date is not None:
94 ashish 7555 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7556 
      oprot.writeI64(self.from_date)
7557 
      oprot.writeFieldEnd()
3431 rajveer 7558 
    if self.to_date is not None:
94 ashish 7559 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7560 
      oprot.writeI64(self.to_date)
7561 
      oprot.writeFieldEnd()
3431 rajveer 7562 
    if self.status is not None:
94 ashish 7563 
      oprot.writeFieldBegin('status', TType.I32, 4)
7564 
      oprot.writeI32(self.status)
7565 
      oprot.writeFieldEnd()
7566 
    oprot.writeFieldStop()
7567 
    oprot.writeStructEnd()
7568 
 
3431 rajveer 7569 
  def validate(self):
7570 
    return
7571 
 
7572 
 
94 ashish 7573 
  def __repr__(self):
7574 
    L = ['%s=%r' % (key, value)
7575 
      for key, value in self.__dict__.iteritems()]
7576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7577 
 
7578 
  def __eq__(self, other):
7579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7580 
 
7581 
  def __ne__(self, other):
7582 
    return not (self == other)
7583 
 
7584 
class getTransactionsForCustomer_result:
7585 
  """
7586 
  Attributes:
7587 
   - success
7588 
   - ex
7589 
  """
7590 
 
7591 
  thrift_spec = (
7592 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7594 
  )
7595 
 
7596 
  def __init__(self, success=None, ex=None,):
7597 
    self.success = success
7598 
    self.ex = ex
7599 
 
7600 
  def read(self, iprot):
7601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7603 
      return
7604 
    iprot.readStructBegin()
7605 
    while True:
7606 
      (fname, ftype, fid) = iprot.readFieldBegin()
7607 
      if ftype == TType.STOP:
7608 
        break
7609 
      if fid == 0:
7610 
        if ftype == TType.LIST:
7611 
          self.success = []
5031 varun.gupt 7612 
          (_etype66, _size63) = iprot.readListBegin()
7613 
          for _i67 in xrange(_size63):
7614 
            _elem68 = Transaction()
7615 
            _elem68.read(iprot)
7616 
            self.success.append(_elem68)
94 ashish 7617 
          iprot.readListEnd()
7618 
        else:
7619 
          iprot.skip(ftype)
7620 
      elif fid == 1:
7621 
        if ftype == TType.STRUCT:
7622 
          self.ex = TransactionServiceException()
7623 
          self.ex.read(iprot)
7624 
        else:
7625 
          iprot.skip(ftype)
7626 
      else:
7627 
        iprot.skip(ftype)
7628 
      iprot.readFieldEnd()
7629 
    iprot.readStructEnd()
7630 
 
7631 
  def write(self, oprot):
7632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7634 
      return
7635 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7636 
    if self.success is not None:
94 ashish 7637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7639 
      for iter69 in self.success:
7640 
        iter69.write(oprot)
94 ashish 7641 
      oprot.writeListEnd()
7642 
      oprot.writeFieldEnd()
3431 rajveer 7643 
    if self.ex is not None:
94 ashish 7644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7645 
      self.ex.write(oprot)
7646 
      oprot.writeFieldEnd()
7647 
    oprot.writeFieldStop()
7648 
    oprot.writeStructEnd()
7649 
 
3431 rajveer 7650 
  def validate(self):
7651 
    return
7652 
 
7653 
 
94 ashish 7654 
  def __repr__(self):
7655 
    L = ['%s=%r' % (key, value)
7656 
      for key, value in self.__dict__.iteritems()]
7657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7658 
 
7659 
  def __eq__(self, other):
7660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7661 
 
7662 
  def __ne__(self, other):
7663 
    return not (self == other)
7664 
 
132 ashish 7665 
class getTransactionsForShoppingCartId_args:
7666 
  """
7667 
  Attributes:
7668 
   - shoppingCartId
7669 
  """
7670 
 
7671 
  thrift_spec = (
7672 
    None, # 0
7673 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7674 
  )
7675 
 
7676 
  def __init__(self, shoppingCartId=None,):
7677 
    self.shoppingCartId = shoppingCartId
7678 
 
7679 
  def read(self, iprot):
7680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7682 
      return
7683 
    iprot.readStructBegin()
7684 
    while True:
7685 
      (fname, ftype, fid) = iprot.readFieldBegin()
7686 
      if ftype == TType.STOP:
7687 
        break
7688 
      if fid == 1:
7689 
        if ftype == TType.I64:
7690 
          self.shoppingCartId = iprot.readI64();
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      else:
7694 
        iprot.skip(ftype)
7695 
      iprot.readFieldEnd()
7696 
    iprot.readStructEnd()
7697 
 
7698 
  def write(self, oprot):
7699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7701 
      return
7702 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7703 
    if self.shoppingCartId is not None:
132 ashish 7704 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7705 
      oprot.writeI64(self.shoppingCartId)
7706 
      oprot.writeFieldEnd()
7707 
    oprot.writeFieldStop()
7708 
    oprot.writeStructEnd()
7709 
 
3431 rajveer 7710 
  def validate(self):
7711 
    return
7712 
 
7713 
 
132 ashish 7714 
  def __repr__(self):
7715 
    L = ['%s=%r' % (key, value)
7716 
      for key, value in self.__dict__.iteritems()]
7717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7718 
 
7719 
  def __eq__(self, other):
7720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7721 
 
7722 
  def __ne__(self, other):
7723 
    return not (self == other)
7724 
 
7725 
class getTransactionsForShoppingCartId_result:
7726 
  """
7727 
  Attributes:
7728 
   - success
7729 
   - ex
7730 
  """
7731 
 
7732 
  thrift_spec = (
7733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7735 
  )
7736 
 
7737 
  def __init__(self, success=None, ex=None,):
7738 
    self.success = success
7739 
    self.ex = ex
7740 
 
7741 
  def read(self, iprot):
7742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7744 
      return
7745 
    iprot.readStructBegin()
7746 
    while True:
7747 
      (fname, ftype, fid) = iprot.readFieldBegin()
7748 
      if ftype == TType.STOP:
7749 
        break
7750 
      if fid == 0:
7751 
        if ftype == TType.LIST:
7752 
          self.success = []
5031 varun.gupt 7753 
          (_etype73, _size70) = iprot.readListBegin()
7754 
          for _i74 in xrange(_size70):
7755 
            _elem75 = Transaction()
7756 
            _elem75.read(iprot)
7757 
            self.success.append(_elem75)
132 ashish 7758 
          iprot.readListEnd()
7759 
        else:
7760 
          iprot.skip(ftype)
7761 
      elif fid == 1:
7762 
        if ftype == TType.STRUCT:
7763 
          self.ex = TransactionServiceException()
7764 
          self.ex.read(iprot)
7765 
        else:
7766 
          iprot.skip(ftype)
7767 
      else:
7768 
        iprot.skip(ftype)
7769 
      iprot.readFieldEnd()
7770 
    iprot.readStructEnd()
7771 
 
7772 
  def write(self, oprot):
7773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7775 
      return
7776 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7777 
    if self.success is not None:
132 ashish 7778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7780 
      for iter76 in self.success:
7781 
        iter76.write(oprot)
132 ashish 7782 
      oprot.writeListEnd()
7783 
      oprot.writeFieldEnd()
3431 rajveer 7784 
    if self.ex is not None:
132 ashish 7785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7786 
      self.ex.write(oprot)
7787 
      oprot.writeFieldEnd()
7788 
    oprot.writeFieldStop()
7789 
    oprot.writeStructEnd()
7790 
 
3431 rajveer 7791 
  def validate(self):
7792 
    return
7793 
 
7794 
 
132 ashish 7795 
  def __repr__(self):
7796 
    L = ['%s=%r' % (key, value)
7797 
      for key, value in self.__dict__.iteritems()]
7798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7799 
 
7800 
  def __eq__(self, other):
7801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7802 
 
7803 
  def __ne__(self, other):
7804 
    return not (self == other)
7805 
 
94 ashish 7806 
class getTransactionStatus_args:
7807 
  """
7808 
  Attributes:
7809 
   - transactionId
7810 
  """
7811 
 
7812 
  thrift_spec = (
7813 
    None, # 0
7814 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7815 
  )
7816 
 
7817 
  def __init__(self, transactionId=None,):
7818 
    self.transactionId = transactionId
7819 
 
7820 
  def read(self, iprot):
7821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7823 
      return
7824 
    iprot.readStructBegin()
7825 
    while True:
7826 
      (fname, ftype, fid) = iprot.readFieldBegin()
7827 
      if ftype == TType.STOP:
7828 
        break
7829 
      if fid == 1:
7830 
        if ftype == TType.I64:
7831 
          self.transactionId = iprot.readI64();
7832 
        else:
7833 
          iprot.skip(ftype)
7834 
      else:
7835 
        iprot.skip(ftype)
7836 
      iprot.readFieldEnd()
7837 
    iprot.readStructEnd()
7838 
 
7839 
  def write(self, oprot):
7840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7842 
      return
7843 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7844 
    if self.transactionId is not None:
94 ashish 7845 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7846 
      oprot.writeI64(self.transactionId)
7847 
      oprot.writeFieldEnd()
7848 
    oprot.writeFieldStop()
7849 
    oprot.writeStructEnd()
7850 
 
3431 rajveer 7851 
  def validate(self):
7852 
    return
7853 
 
7854 
 
94 ashish 7855 
  def __repr__(self):
7856 
    L = ['%s=%r' % (key, value)
7857 
      for key, value in self.__dict__.iteritems()]
7858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7859 
 
7860 
  def __eq__(self, other):
7861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7862 
 
7863 
  def __ne__(self, other):
7864 
    return not (self == other)
7865 
 
7866 
class getTransactionStatus_result:
7867 
  """
7868 
  Attributes:
7869 
   - success
7870 
   - ex
7871 
  """
7872 
 
7873 
  thrift_spec = (
7874 
    (0, TType.I32, 'success', None, None, ), # 0
7875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7876 
  )
7877 
 
7878 
  def __init__(self, success=None, ex=None,):
7879 
    self.success = success
7880 
    self.ex = ex
7881 
 
7882 
  def read(self, iprot):
7883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7885 
      return
7886 
    iprot.readStructBegin()
7887 
    while True:
7888 
      (fname, ftype, fid) = iprot.readFieldBegin()
7889 
      if ftype == TType.STOP:
7890 
        break
7891 
      if fid == 0:
7892 
        if ftype == TType.I32:
7893 
          self.success = iprot.readI32();
7894 
        else:
7895 
          iprot.skip(ftype)
7896 
      elif fid == 1:
7897 
        if ftype == TType.STRUCT:
7898 
          self.ex = TransactionServiceException()
7899 
          self.ex.read(iprot)
7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      else:
7903 
        iprot.skip(ftype)
7904 
      iprot.readFieldEnd()
7905 
    iprot.readStructEnd()
7906 
 
7907 
  def write(self, oprot):
7908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7910 
      return
7911 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7912 
    if self.success is not None:
94 ashish 7913 
      oprot.writeFieldBegin('success', TType.I32, 0)
7914 
      oprot.writeI32(self.success)
7915 
      oprot.writeFieldEnd()
3431 rajveer 7916 
    if self.ex is not None:
94 ashish 7917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7918 
      self.ex.write(oprot)
7919 
      oprot.writeFieldEnd()
7920 
    oprot.writeFieldStop()
7921 
    oprot.writeStructEnd()
7922 
 
3431 rajveer 7923 
  def validate(self):
7924 
    return
7925 
 
7926 
 
94 ashish 7927 
  def __repr__(self):
7928 
    L = ['%s=%r' % (key, value)
7929 
      for key, value in self.__dict__.iteritems()]
7930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7931 
 
7932 
  def __eq__(self, other):
7933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7934 
 
7935 
  def __ne__(self, other):
7936 
    return not (self == other)
7937 
 
7938 
class changeTransactionStatus_args:
7939 
  """
7940 
  Attributes:
7941 
   - transactionId
7942 
   - status
7943 
   - description
5527 anupam.sin 7944 
   - pickUp
7945 
   - orderType
94 ashish 7946 
  """
7947 
 
7948 
  thrift_spec = (
7949 
    None, # 0
7950 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7951 
    (2, TType.I32, 'status', None, None, ), # 2
7952 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 7953 
    (4, TType.I64, 'pickUp', None, None, ), # 4
7954 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 7955 
  )
7956 
 
5527 anupam.sin 7957 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 7958 
    self.transactionId = transactionId
7959 
    self.status = status
7960 
    self.description = description
5527 anupam.sin 7961 
    self.pickUp = pickUp
7962 
    self.orderType = orderType
94 ashish 7963 
 
7964 
  def read(self, iprot):
7965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7967 
      return
7968 
    iprot.readStructBegin()
7969 
    while True:
7970 
      (fname, ftype, fid) = iprot.readFieldBegin()
7971 
      if ftype == TType.STOP:
7972 
        break
7973 
      if fid == 1:
7974 
        if ftype == TType.I64:
7975 
          self.transactionId = iprot.readI64();
7976 
        else:
7977 
          iprot.skip(ftype)
7978 
      elif fid == 2:
7979 
        if ftype == TType.I32:
7980 
          self.status = iprot.readI32();
7981 
        else:
7982 
          iprot.skip(ftype)
7983 
      elif fid == 3:
7984 
        if ftype == TType.STRING:
7985 
          self.description = iprot.readString();
7986 
        else:
7987 
          iprot.skip(ftype)
5387 rajveer 7988 
      elif fid == 4:
5527 anupam.sin 7989 
        if ftype == TType.I64:
7990 
          self.pickUp = iprot.readI64();
5387 rajveer 7991 
        else:
7992 
          iprot.skip(ftype)
5527 anupam.sin 7993 
      elif fid == 5:
7994 
        if ftype == TType.I32:
7995 
          self.orderType = iprot.readI32();
7996 
        else:
7997 
          iprot.skip(ftype)
94 ashish 7998 
      else:
7999 
        iprot.skip(ftype)
8000 
      iprot.readFieldEnd()
8001 
    iprot.readStructEnd()
8002 
 
8003 
  def write(self, oprot):
8004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8006 
      return
8007 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8008 
    if self.transactionId is not None:
94 ashish 8009 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8010 
      oprot.writeI64(self.transactionId)
8011 
      oprot.writeFieldEnd()
3431 rajveer 8012 
    if self.status is not None:
94 ashish 8013 
      oprot.writeFieldBegin('status', TType.I32, 2)
8014 
      oprot.writeI32(self.status)
8015 
      oprot.writeFieldEnd()
3431 rajveer 8016 
    if self.description is not None:
94 ashish 8017 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8018 
      oprot.writeString(self.description)
8019 
      oprot.writeFieldEnd()
5527 anupam.sin 8020 
    if self.pickUp is not None:
8021 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8022 
      oprot.writeI64(self.pickUp)
5387 rajveer 8023 
      oprot.writeFieldEnd()
5527 anupam.sin 8024 
    if self.orderType is not None:
8025 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8026 
      oprot.writeI32(self.orderType)
8027 
      oprot.writeFieldEnd()
94 ashish 8028 
    oprot.writeFieldStop()
8029 
    oprot.writeStructEnd()
8030 
 
3431 rajveer 8031 
  def validate(self):
8032 
    return
8033 
 
8034 
 
94 ashish 8035 
  def __repr__(self):
8036 
    L = ['%s=%r' % (key, value)
8037 
      for key, value in self.__dict__.iteritems()]
8038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8039 
 
8040 
  def __eq__(self, other):
8041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8042 
 
8043 
  def __ne__(self, other):
8044 
    return not (self == other)
8045 
 
8046 
class changeTransactionStatus_result:
8047 
  """
8048 
  Attributes:
8049 
   - success
8050 
   - ex
8051 
  """
8052 
 
8053 
  thrift_spec = (
8054 
    (0, TType.BOOL, 'success', None, None, ), # 0
8055 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8056 
  )
8057 
 
8058 
  def __init__(self, success=None, ex=None,):
8059 
    self.success = success
8060 
    self.ex = ex
8061 
 
8062 
  def read(self, iprot):
8063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8065 
      return
8066 
    iprot.readStructBegin()
8067 
    while True:
8068 
      (fname, ftype, fid) = iprot.readFieldBegin()
8069 
      if ftype == TType.STOP:
8070 
        break
8071 
      if fid == 0:
8072 
        if ftype == TType.BOOL:
8073 
          self.success = iprot.readBool();
8074 
        else:
8075 
          iprot.skip(ftype)
8076 
      elif fid == 1:
8077 
        if ftype == TType.STRUCT:
8078 
          self.ex = TransactionServiceException()
8079 
          self.ex.read(iprot)
8080 
        else:
8081 
          iprot.skip(ftype)
8082 
      else:
8083 
        iprot.skip(ftype)
8084 
      iprot.readFieldEnd()
8085 
    iprot.readStructEnd()
8086 
 
8087 
  def write(self, oprot):
8088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8090 
      return
8091 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8092 
    if self.success is not None:
94 ashish 8093 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8094 
      oprot.writeBool(self.success)
8095 
      oprot.writeFieldEnd()
3431 rajveer 8096 
    if self.ex is not None:
94 ashish 8097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8098 
      self.ex.write(oprot)
8099 
      oprot.writeFieldEnd()
8100 
    oprot.writeFieldStop()
8101 
    oprot.writeStructEnd()
8102 
 
3431 rajveer 8103 
  def validate(self):
8104 
    return
8105 
 
8106 
 
94 ashish 8107 
  def __repr__(self):
8108 
    L = ['%s=%r' % (key, value)
8109 
      for key, value in self.__dict__.iteritems()]
8110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8111 
 
8112 
  def __eq__(self, other):
8113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8114 
 
8115 
  def __ne__(self, other):
8116 
    return not (self == other)
8117 
 
1398 varun.gupt 8118 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8119 
  """
8120 
  Attributes:
8121 
   - transactionId
8122 
  """
8123 
 
8124 
  thrift_spec = (
8125 
    None, # 0
8126 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8127 
  )
8128 
 
8129 
  def __init__(self, transactionId=None,):
8130 
    self.transactionId = transactionId
8131 
 
8132 
  def read(self, iprot):
8133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8135 
      return
8136 
    iprot.readStructBegin()
8137 
    while True:
8138 
      (fname, ftype, fid) = iprot.readFieldBegin()
8139 
      if ftype == TType.STOP:
8140 
        break
8141 
      if fid == 1:
8142 
        if ftype == TType.I64:
8143 
          self.transactionId = iprot.readI64();
8144 
        else:
8145 
          iprot.skip(ftype)
8146 
      else:
8147 
        iprot.skip(ftype)
8148 
      iprot.readFieldEnd()
8149 
    iprot.readStructEnd()
8150 
 
8151 
  def write(self, oprot):
8152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8154 
      return
1398 varun.gupt 8155 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8156 
    if self.transactionId is not None:
1382 varun.gupt 8157 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8158 
      oprot.writeI64(self.transactionId)
8159 
      oprot.writeFieldEnd()
8160 
    oprot.writeFieldStop()
8161 
    oprot.writeStructEnd()
8162 
 
3431 rajveer 8163 
  def validate(self):
8164 
    return
8165 
 
8166 
 
1382 varun.gupt 8167 
  def __repr__(self):
8168 
    L = ['%s=%r' % (key, value)
8169 
      for key, value in self.__dict__.iteritems()]
8170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8171 
 
8172 
  def __eq__(self, other):
8173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8174 
 
8175 
  def __ne__(self, other):
8176 
    return not (self == other)
8177 
 
1398 varun.gupt 8178 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8179 
  """
8180 
  Attributes:
8181 
   - success
8182 
   - ex
8183 
  """
8184 
 
8185 
  thrift_spec = (
8186 
    (0, TType.BOOL, 'success', None, None, ), # 0
8187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8188 
  )
8189 
 
8190 
  def __init__(self, success=None, ex=None,):
8191 
    self.success = success
8192 
    self.ex = ex
8193 
 
8194 
  def read(self, iprot):
8195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8197 
      return
8198 
    iprot.readStructBegin()
8199 
    while True:
8200 
      (fname, ftype, fid) = iprot.readFieldBegin()
8201 
      if ftype == TType.STOP:
8202 
        break
8203 
      if fid == 0:
8204 
        if ftype == TType.BOOL:
8205 
          self.success = iprot.readBool();
8206 
        else:
8207 
          iprot.skip(ftype)
8208 
      elif fid == 1:
8209 
        if ftype == TType.STRUCT:
8210 
          self.ex = TransactionServiceException()
8211 
          self.ex.read(iprot)
8212 
        else:
8213 
          iprot.skip(ftype)
8214 
      else:
8215 
        iprot.skip(ftype)
8216 
      iprot.readFieldEnd()
8217 
    iprot.readStructEnd()
8218 
 
8219 
  def write(self, oprot):
8220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8222 
      return
1398 varun.gupt 8223 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8224 
    if self.success is not None:
1382 varun.gupt 8225 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8226 
      oprot.writeBool(self.success)
8227 
      oprot.writeFieldEnd()
3431 rajveer 8228 
    if self.ex is not None:
1382 varun.gupt 8229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8230 
      self.ex.write(oprot)
8231 
      oprot.writeFieldEnd()
8232 
    oprot.writeFieldStop()
8233 
    oprot.writeStructEnd()
8234 
 
3431 rajveer 8235 
  def validate(self):
8236 
    return
8237 
 
8238 
 
1382 varun.gupt 8239 
  def __repr__(self):
8240 
    L = ['%s=%r' % (key, value)
8241 
      for key, value in self.__dict__.iteritems()]
8242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8243 
 
8244 
  def __eq__(self, other):
8245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8246 
 
8247 
  def __ne__(self, other):
8248 
    return not (self == other)
8249 
 
483 rajveer 8250 
class getAllOrders_args:
94 ashish 8251 
  """
8252 
  Attributes:
4801 anupam.sin 8253 
   - statuses
483 rajveer 8254 
   - from_date
8255 
   - to_date
8256 
   - warehouse_id
94 ashish 8257 
  """
8258 
 
8259 
  thrift_spec = (
8260 
    None, # 0
4801 anupam.sin 8261 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8262 
    (2, TType.I64, 'from_date', None, None, ), # 2
8263 
    (3, TType.I64, 'to_date', None, None, ), # 3
8264 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8265 
  )
8266 
 
4801 anupam.sin 8267 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8268 
    self.statuses = statuses
483 rajveer 8269 
    self.from_date = from_date
8270 
    self.to_date = to_date
8271 
    self.warehouse_id = warehouse_id
94 ashish 8272 
 
8273 
  def read(self, iprot):
8274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8276 
      return
8277 
    iprot.readStructBegin()
8278 
    while True:
8279 
      (fname, ftype, fid) = iprot.readFieldBegin()
8280 
      if ftype == TType.STOP:
8281 
        break
8282 
      if fid == 1:
4801 anupam.sin 8283 
        if ftype == TType.LIST:
8284 
          self.statuses = []
5031 varun.gupt 8285 
          (_etype80, _size77) = iprot.readListBegin()
8286 
          for _i81 in xrange(_size77):
8287 
            _elem82 = iprot.readI32();
8288 
            self.statuses.append(_elem82)
4801 anupam.sin 8289 
          iprot.readListEnd()
94 ashish 8290 
        else:
8291 
          iprot.skip(ftype)
483 rajveer 8292 
      elif fid == 2:
8293 
        if ftype == TType.I64:
8294 
          self.from_date = iprot.readI64();
94 ashish 8295 
        else:
8296 
          iprot.skip(ftype)
483 rajveer 8297 
      elif fid == 3:
8298 
        if ftype == TType.I64:
8299 
          self.to_date = iprot.readI64();
94 ashish 8300 
        else:
8301 
          iprot.skip(ftype)
483 rajveer 8302 
      elif fid == 4:
94 ashish 8303 
        if ftype == TType.I64:
483 rajveer 8304 
          self.warehouse_id = iprot.readI64();
94 ashish 8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      else:
8308 
        iprot.skip(ftype)
8309 
      iprot.readFieldEnd()
8310 
    iprot.readStructEnd()
8311 
 
8312 
  def write(self, oprot):
8313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8315 
      return
483 rajveer 8316 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8317 
    if self.statuses is not None:
8318 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8319 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8320 
      for iter83 in self.statuses:
8321 
        oprot.writeI32(iter83)
4801 anupam.sin 8322 
      oprot.writeListEnd()
94 ashish 8323 
      oprot.writeFieldEnd()
3431 rajveer 8324 
    if self.from_date is not None:
483 rajveer 8325 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8326 
      oprot.writeI64(self.from_date)
94 ashish 8327 
      oprot.writeFieldEnd()
3431 rajveer 8328 
    if self.to_date is not None:
483 rajveer 8329 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8330 
      oprot.writeI64(self.to_date)
94 ashish 8331 
      oprot.writeFieldEnd()
3431 rajveer 8332 
    if self.warehouse_id is not None:
483 rajveer 8333 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8334 
      oprot.writeI64(self.warehouse_id)
94 ashish 8335 
      oprot.writeFieldEnd()
8336 
    oprot.writeFieldStop()
8337 
    oprot.writeStructEnd()
8338 
 
3431 rajveer 8339 
  def validate(self):
8340 
    return
8341 
 
8342 
 
94 ashish 8343 
  def __repr__(self):
8344 
    L = ['%s=%r' % (key, value)
8345 
      for key, value in self.__dict__.iteritems()]
8346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8347 
 
8348 
  def __eq__(self, other):
8349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8350 
 
8351 
  def __ne__(self, other):
8352 
    return not (self == other)
8353 
 
483 rajveer 8354 
class getAllOrders_result:
94 ashish 8355 
  """
8356 
  Attributes:
8357 
   - success
8358 
   - ex
8359 
  """
8360 
 
8361 
  thrift_spec = (
483 rajveer 8362 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8364 
  )
8365 
 
8366 
  def __init__(self, success=None, ex=None,):
8367 
    self.success = success
8368 
    self.ex = ex
8369 
 
8370 
  def read(self, iprot):
8371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8373 
      return
8374 
    iprot.readStructBegin()
8375 
    while True:
8376 
      (fname, ftype, fid) = iprot.readFieldBegin()
8377 
      if ftype == TType.STOP:
8378 
        break
8379 
      if fid == 0:
483 rajveer 8380 
        if ftype == TType.LIST:
8381 
          self.success = []
5031 varun.gupt 8382 
          (_etype87, _size84) = iprot.readListBegin()
8383 
          for _i88 in xrange(_size84):
8384 
            _elem89 = Order()
8385 
            _elem89.read(iprot)
8386 
            self.success.append(_elem89)
483 rajveer 8387 
          iprot.readListEnd()
94 ashish 8388 
        else:
8389 
          iprot.skip(ftype)
8390 
      elif fid == 1:
8391 
        if ftype == TType.STRUCT:
8392 
          self.ex = TransactionServiceException()
8393 
          self.ex.read(iprot)
8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      else:
8397 
        iprot.skip(ftype)
8398 
      iprot.readFieldEnd()
8399 
    iprot.readStructEnd()
8400 
 
8401 
  def write(self, oprot):
8402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8404 
      return
483 rajveer 8405 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8406 
    if self.success is not None:
483 rajveer 8407 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8408 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8409 
      for iter90 in self.success:
8410 
        iter90.write(oprot)
483 rajveer 8411 
      oprot.writeListEnd()
94 ashish 8412 
      oprot.writeFieldEnd()
3431 rajveer 8413 
    if self.ex is not None:
94 ashish 8414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8415 
      self.ex.write(oprot)
8416 
      oprot.writeFieldEnd()
8417 
    oprot.writeFieldStop()
8418 
    oprot.writeStructEnd()
8419 
 
3431 rajveer 8420 
  def validate(self):
8421 
    return
8422 
 
8423 
 
94 ashish 8424 
  def __repr__(self):
8425 
    L = ['%s=%r' % (key, value)
8426 
      for key, value in self.__dict__.iteritems()]
8427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8428 
 
8429 
  def __eq__(self, other):
8430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8431 
 
8432 
  def __ne__(self, other):
8433 
    return not (self == other)
8434 
 
4133 chandransh 8435 
class getOrdersInBatch_args:
8436 
  """
8437 
  Attributes:
8438 
   - statuses
8439 
   - offset
8440 
   - limit
8441 
   - warehouse_id
8442 
  """
8443 
 
8444 
  thrift_spec = (
8445 
    None, # 0
8446 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8447 
    (2, TType.I64, 'offset', None, None, ), # 2
8448 
    (3, TType.I64, 'limit', None, None, ), # 3
8449 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8450 
  )
8451 
 
8452 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8453 
    self.statuses = statuses
8454 
    self.offset = offset
8455 
    self.limit = limit
8456 
    self.warehouse_id = warehouse_id
8457 
 
8458 
  def read(self, iprot):
8459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8461 
      return
8462 
    iprot.readStructBegin()
8463 
    while True:
8464 
      (fname, ftype, fid) = iprot.readFieldBegin()
8465 
      if ftype == TType.STOP:
8466 
        break
8467 
      if fid == 1:
8468 
        if ftype == TType.LIST:
8469 
          self.statuses = []
5031 varun.gupt 8470 
          (_etype94, _size91) = iprot.readListBegin()
8471 
          for _i95 in xrange(_size91):
8472 
            _elem96 = iprot.readI32();
8473 
            self.statuses.append(_elem96)
4133 chandransh 8474 
          iprot.readListEnd()
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      elif fid == 2:
8478 
        if ftype == TType.I64:
8479 
          self.offset = iprot.readI64();
8480 
        else:
8481 
          iprot.skip(ftype)
8482 
      elif fid == 3:
8483 
        if ftype == TType.I64:
8484 
          self.limit = iprot.readI64();
8485 
        else:
8486 
          iprot.skip(ftype)
8487 
      elif fid == 4:
8488 
        if ftype == TType.I64:
8489 
          self.warehouse_id = iprot.readI64();
8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      else:
8493 
        iprot.skip(ftype)
8494 
      iprot.readFieldEnd()
8495 
    iprot.readStructEnd()
8496 
 
8497 
  def write(self, oprot):
8498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8500 
      return
8501 
    oprot.writeStructBegin('getOrdersInBatch_args')
8502 
    if self.statuses is not None:
8503 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8504 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8505 
      for iter97 in self.statuses:
8506 
        oprot.writeI32(iter97)
4133 chandransh 8507 
      oprot.writeListEnd()
8508 
      oprot.writeFieldEnd()
8509 
    if self.offset is not None:
8510 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8511 
      oprot.writeI64(self.offset)
8512 
      oprot.writeFieldEnd()
8513 
    if self.limit is not None:
8514 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8515 
      oprot.writeI64(self.limit)
8516 
      oprot.writeFieldEnd()
8517 
    if self.warehouse_id is not None:
8518 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8519 
      oprot.writeI64(self.warehouse_id)
8520 
      oprot.writeFieldEnd()
8521 
    oprot.writeFieldStop()
8522 
    oprot.writeStructEnd()
8523 
 
8524 
  def validate(self):
8525 
    return
8526 
 
8527 
 
8528 
  def __repr__(self):
8529 
    L = ['%s=%r' % (key, value)
8530 
      for key, value in self.__dict__.iteritems()]
8531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8532 
 
8533 
  def __eq__(self, other):
8534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8535 
 
8536 
  def __ne__(self, other):
8537 
    return not (self == other)
8538 
 
8539 
class getOrdersInBatch_result:
8540 
  """
8541 
  Attributes:
8542 
   - success
8543 
   - ex
8544 
  """
8545 
 
8546 
  thrift_spec = (
8547 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8549 
  )
8550 
 
8551 
  def __init__(self, success=None, ex=None,):
8552 
    self.success = success
8553 
    self.ex = ex
8554 
 
8555 
  def read(self, iprot):
8556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8558 
      return
8559 
    iprot.readStructBegin()
8560 
    while True:
8561 
      (fname, ftype, fid) = iprot.readFieldBegin()
8562 
      if ftype == TType.STOP:
8563 
        break
8564 
      if fid == 0:
8565 
        if ftype == TType.LIST:
8566 
          self.success = []
5031 varun.gupt 8567 
          (_etype101, _size98) = iprot.readListBegin()
8568 
          for _i102 in xrange(_size98):
8569 
            _elem103 = Order()
8570 
            _elem103.read(iprot)
8571 
            self.success.append(_elem103)
4133 chandransh 8572 
          iprot.readListEnd()
8573 
        else:
8574 
          iprot.skip(ftype)
8575 
      elif fid == 1:
8576 
        if ftype == TType.STRUCT:
8577 
          self.ex = TransactionServiceException()
8578 
          self.ex.read(iprot)
8579 
        else:
8580 
          iprot.skip(ftype)
8581 
      else:
8582 
        iprot.skip(ftype)
8583 
      iprot.readFieldEnd()
8584 
    iprot.readStructEnd()
8585 
 
8586 
  def write(self, oprot):
8587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8589 
      return
8590 
    oprot.writeStructBegin('getOrdersInBatch_result')
8591 
    if self.success is not None:
8592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8594 
      for iter104 in self.success:
8595 
        iter104.write(oprot)
4133 chandransh 8596 
      oprot.writeListEnd()
8597 
      oprot.writeFieldEnd()
8598 
    if self.ex is not None:
8599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8600 
      self.ex.write(oprot)
8601 
      oprot.writeFieldEnd()
8602 
    oprot.writeFieldStop()
8603 
    oprot.writeStructEnd()
8604 
 
8605 
  def validate(self):
8606 
    return
8607 
 
8608 
 
8609 
  def __repr__(self):
8610 
    L = ['%s=%r' % (key, value)
8611 
      for key, value in self.__dict__.iteritems()]
8612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8613 
 
8614 
  def __eq__(self, other):
8615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8616 
 
8617 
  def __ne__(self, other):
8618 
    return not (self == other)
8619 
 
8620 
class getOrderCount_args:
8621 
  """
8622 
  Attributes:
8623 
   - statuses
8624 
   - warehouseId
8625 
  """
8626 
 
8627 
  thrift_spec = (
8628 
    None, # 0
8629 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8630 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8631 
  )
8632 
 
8633 
  def __init__(self, statuses=None, warehouseId=None,):
8634 
    self.statuses = statuses
8635 
    self.warehouseId = warehouseId
8636 
 
8637 
  def read(self, iprot):
8638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8640 
      return
8641 
    iprot.readStructBegin()
8642 
    while True:
8643 
      (fname, ftype, fid) = iprot.readFieldBegin()
8644 
      if ftype == TType.STOP:
8645 
        break
8646 
      if fid == 1:
8647 
        if ftype == TType.LIST:
8648 
          self.statuses = []
5031 varun.gupt 8649 
          (_etype108, _size105) = iprot.readListBegin()
8650 
          for _i109 in xrange(_size105):
8651 
            _elem110 = iprot.readI32();
8652 
            self.statuses.append(_elem110)
4133 chandransh 8653 
          iprot.readListEnd()
8654 
        else:
8655 
          iprot.skip(ftype)
8656 
      elif fid == 2:
8657 
        if ftype == TType.I64:
8658 
          self.warehouseId = iprot.readI64();
8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      else:
8662 
        iprot.skip(ftype)
8663 
      iprot.readFieldEnd()
8664 
    iprot.readStructEnd()
8665 
 
8666 
  def write(self, oprot):
8667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8669 
      return
8670 
    oprot.writeStructBegin('getOrderCount_args')
8671 
    if self.statuses is not None:
8672 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8673 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8674 
      for iter111 in self.statuses:
8675 
        oprot.writeI32(iter111)
4133 chandransh 8676 
      oprot.writeListEnd()
8677 
      oprot.writeFieldEnd()
8678 
    if self.warehouseId is not None:
8679 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8680 
      oprot.writeI64(self.warehouseId)
8681 
      oprot.writeFieldEnd()
8682 
    oprot.writeFieldStop()
8683 
    oprot.writeStructEnd()
8684 
 
8685 
  def validate(self):
8686 
    return
8687 
 
8688 
 
8689 
  def __repr__(self):
8690 
    L = ['%s=%r' % (key, value)
8691 
      for key, value in self.__dict__.iteritems()]
8692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8693 
 
8694 
  def __eq__(self, other):
8695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8696 
 
8697 
  def __ne__(self, other):
8698 
    return not (self == other)
8699 
 
8700 
class getOrderCount_result:
8701 
  """
8702 
  Attributes:
8703 
   - success
8704 
   - ex
8705 
  """
8706 
 
8707 
  thrift_spec = (
8708 
    (0, TType.I32, 'success', None, None, ), # 0
8709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8710 
  )
8711 
 
8712 
  def __init__(self, success=None, ex=None,):
8713 
    self.success = success
8714 
    self.ex = ex
8715 
 
8716 
  def read(self, iprot):
8717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8719 
      return
8720 
    iprot.readStructBegin()
8721 
    while True:
8722 
      (fname, ftype, fid) = iprot.readFieldBegin()
8723 
      if ftype == TType.STOP:
8724 
        break
8725 
      if fid == 0:
8726 
        if ftype == TType.I32:
8727 
          self.success = iprot.readI32();
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      elif fid == 1:
8731 
        if ftype == TType.STRUCT:
8732 
          self.ex = TransactionServiceException()
8733 
          self.ex.read(iprot)
8734 
        else:
8735 
          iprot.skip(ftype)
8736 
      else:
8737 
        iprot.skip(ftype)
8738 
      iprot.readFieldEnd()
8739 
    iprot.readStructEnd()
8740 
 
8741 
  def write(self, oprot):
8742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8744 
      return
8745 
    oprot.writeStructBegin('getOrderCount_result')
8746 
    if self.success is not None:
8747 
      oprot.writeFieldBegin('success', TType.I32, 0)
8748 
      oprot.writeI32(self.success)
8749 
      oprot.writeFieldEnd()
8750 
    if self.ex is not None:
8751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8752 
      self.ex.write(oprot)
8753 
      oprot.writeFieldEnd()
8754 
    oprot.writeFieldStop()
8755 
    oprot.writeStructEnd()
8756 
 
8757 
  def validate(self):
8758 
    return
8759 
 
8760 
 
8761 
  def __repr__(self):
8762 
    L = ['%s=%r' % (key, value)
8763 
      for key, value in self.__dict__.iteritems()]
8764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8765 
 
8766 
  def __eq__(self, other):
8767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8768 
 
8769 
  def __ne__(self, other):
8770 
    return not (self == other)
8771 
 
999 varun.gupt 8772 
class getOrdersByBillingDate_args:
8773 
  """
8774 
  Attributes:
8775 
   - status
8776 
   - start_billing_date
8777 
   - end_billing_date
8778 
   - warehouse_id
8779 
  """
8780 
 
8781 
  thrift_spec = (
8782 
    None, # 0
8783 
    (1, TType.I32, 'status', None, None, ), # 1
8784 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8785 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8786 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8787 
  )
8788 
 
8789 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8790 
    self.status = status
8791 
    self.start_billing_date = start_billing_date
8792 
    self.end_billing_date = end_billing_date
8793 
    self.warehouse_id = warehouse_id
8794 
 
8795 
  def read(self, iprot):
8796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8798 
      return
8799 
    iprot.readStructBegin()
8800 
    while True:
8801 
      (fname, ftype, fid) = iprot.readFieldBegin()
8802 
      if ftype == TType.STOP:
8803 
        break
8804 
      if fid == 1:
8805 
        if ftype == TType.I32:
8806 
          self.status = iprot.readI32();
8807 
        else:
8808 
          iprot.skip(ftype)
8809 
      elif fid == 2:
8810 
        if ftype == TType.I64:
8811 
          self.start_billing_date = iprot.readI64();
8812 
        else:
8813 
          iprot.skip(ftype)
8814 
      elif fid == 3:
8815 
        if ftype == TType.I64:
8816 
          self.end_billing_date = iprot.readI64();
8817 
        else:
8818 
          iprot.skip(ftype)
8819 
      elif fid == 4:
8820 
        if ftype == TType.I64:
8821 
          self.warehouse_id = iprot.readI64();
8822 
        else:
8823 
          iprot.skip(ftype)
8824 
      else:
8825 
        iprot.skip(ftype)
8826 
      iprot.readFieldEnd()
8827 
    iprot.readStructEnd()
8828 
 
8829 
  def write(self, oprot):
8830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8832 
      return
8833 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8834 
    if self.status is not None:
999 varun.gupt 8835 
      oprot.writeFieldBegin('status', TType.I32, 1)
8836 
      oprot.writeI32(self.status)
8837 
      oprot.writeFieldEnd()
3431 rajveer 8838 
    if self.start_billing_date is not None:
999 varun.gupt 8839 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8840 
      oprot.writeI64(self.start_billing_date)
8841 
      oprot.writeFieldEnd()
3431 rajveer 8842 
    if self.end_billing_date is not None:
999 varun.gupt 8843 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8844 
      oprot.writeI64(self.end_billing_date)
8845 
      oprot.writeFieldEnd()
3431 rajveer 8846 
    if self.warehouse_id is not None:
999 varun.gupt 8847 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8848 
      oprot.writeI64(self.warehouse_id)
8849 
      oprot.writeFieldEnd()
8850 
    oprot.writeFieldStop()
8851 
    oprot.writeStructEnd()
8852 
 
3431 rajveer 8853 
  def validate(self):
8854 
    return
8855 
 
8856 
 
999 varun.gupt 8857 
  def __repr__(self):
8858 
    L = ['%s=%r' % (key, value)
8859 
      for key, value in self.__dict__.iteritems()]
8860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8861 
 
8862 
  def __eq__(self, other):
8863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8864 
 
8865 
  def __ne__(self, other):
8866 
    return not (self == other)
8867 
 
8868 
class getOrdersByBillingDate_result:
8869 
  """
8870 
  Attributes:
8871 
   - success
8872 
   - ex
8873 
  """
8874 
 
8875 
  thrift_spec = (
8876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8878 
  )
8879 
 
8880 
  def __init__(self, success=None, ex=None,):
8881 
    self.success = success
8882 
    self.ex = ex
8883 
 
8884 
  def read(self, iprot):
8885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8887 
      return
8888 
    iprot.readStructBegin()
8889 
    while True:
8890 
      (fname, ftype, fid) = iprot.readFieldBegin()
8891 
      if ftype == TType.STOP:
8892 
        break
8893 
      if fid == 0:
8894 
        if ftype == TType.LIST:
8895 
          self.success = []
5031 varun.gupt 8896 
          (_etype115, _size112) = iprot.readListBegin()
8897 
          for _i116 in xrange(_size112):
8898 
            _elem117 = Order()
8899 
            _elem117.read(iprot)
8900 
            self.success.append(_elem117)
999 varun.gupt 8901 
          iprot.readListEnd()
8902 
        else:
8903 
          iprot.skip(ftype)
8904 
      elif fid == 1:
8905 
        if ftype == TType.STRUCT:
8906 
          self.ex = TransactionServiceException()
8907 
          self.ex.read(iprot)
8908 
        else:
8909 
          iprot.skip(ftype)
8910 
      else:
8911 
        iprot.skip(ftype)
8912 
      iprot.readFieldEnd()
8913 
    iprot.readStructEnd()
8914 
 
8915 
  def write(self, oprot):
8916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8918 
      return
8919 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8920 
    if self.success is not None:
999 varun.gupt 8921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8922 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8923 
      for iter118 in self.success:
8924 
        iter118.write(oprot)
999 varun.gupt 8925 
      oprot.writeListEnd()
8926 
      oprot.writeFieldEnd()
3431 rajveer 8927 
    if self.ex is not None:
999 varun.gupt 8928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8929 
      self.ex.write(oprot)
8930 
      oprot.writeFieldEnd()
8931 
    oprot.writeFieldStop()
8932 
    oprot.writeStructEnd()
8933 
 
3431 rajveer 8934 
  def validate(self):
8935 
    return
8936 
 
8937 
 
999 varun.gupt 8938 
  def __repr__(self):
8939 
    L = ['%s=%r' % (key, value)
8940 
      for key, value in self.__dict__.iteritems()]
8941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8942 
 
8943 
  def __eq__(self, other):
8944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8945 
 
8946 
  def __ne__(self, other):
8947 
    return not (self == other)
8948 
 
3427 chandransh 8949 
class getOrdersByShippingDate_args:
8950 
  """
8951 
  Attributes:
8952 
   - fromShippingDate
8953 
   - toShippingDate
8954 
   - providerId
8955 
   - warehouseId
3451 chandransh 8956 
   - cod
3427 chandransh 8957 
  """
8958 
 
8959 
  thrift_spec = (
8960 
    None, # 0
8961 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8962 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8963 
    (3, TType.I64, 'providerId', None, None, ), # 3
8964 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8965 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8966 
  )
8967 
 
3451 chandransh 8968 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8969 
    self.fromShippingDate = fromShippingDate
8970 
    self.toShippingDate = toShippingDate
8971 
    self.providerId = providerId
8972 
    self.warehouseId = warehouseId
3451 chandransh 8973 
    self.cod = cod
3427 chandransh 8974 
 
8975 
  def read(self, iprot):
8976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8978 
      return
8979 
    iprot.readStructBegin()
8980 
    while True:
8981 
      (fname, ftype, fid) = iprot.readFieldBegin()
8982 
      if ftype == TType.STOP:
8983 
        break
8984 
      if fid == 1:
8985 
        if ftype == TType.I64:
8986 
          self.fromShippingDate = iprot.readI64();
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      elif fid == 2:
8990 
        if ftype == TType.I64:
8991 
          self.toShippingDate = iprot.readI64();
8992 
        else:
8993 
          iprot.skip(ftype)
8994 
      elif fid == 3:
8995 
        if ftype == TType.I64:
8996 
          self.providerId = iprot.readI64();
8997 
        else:
8998 
          iprot.skip(ftype)
8999 
      elif fid == 4:
9000 
        if ftype == TType.I64:
9001 
          self.warehouseId = iprot.readI64();
9002 
        else:
9003 
          iprot.skip(ftype)
3451 chandransh 9004 
      elif fid == 5:
9005 
        if ftype == TType.BOOL:
9006 
          self.cod = iprot.readBool();
9007 
        else:
9008 
          iprot.skip(ftype)
3427 chandransh 9009 
      else:
9010 
        iprot.skip(ftype)
9011 
      iprot.readFieldEnd()
9012 
    iprot.readStructEnd()
9013 
 
9014 
  def write(self, oprot):
9015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9017 
      return
9018 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9019 
    if self.fromShippingDate is not None:
3427 chandransh 9020 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9021 
      oprot.writeI64(self.fromShippingDate)
9022 
      oprot.writeFieldEnd()
3431 rajveer 9023 
    if self.toShippingDate is not None:
3427 chandransh 9024 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9025 
      oprot.writeI64(self.toShippingDate)
9026 
      oprot.writeFieldEnd()
3431 rajveer 9027 
    if self.providerId is not None:
3427 chandransh 9028 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9029 
      oprot.writeI64(self.providerId)
9030 
      oprot.writeFieldEnd()
3431 rajveer 9031 
    if self.warehouseId is not None:
3427 chandransh 9032 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9033 
      oprot.writeI64(self.warehouseId)
9034 
      oprot.writeFieldEnd()
3451 chandransh 9035 
    if self.cod is not None:
9036 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9037 
      oprot.writeBool(self.cod)
9038 
      oprot.writeFieldEnd()
3427 chandransh 9039 
    oprot.writeFieldStop()
9040 
    oprot.writeStructEnd()
9041 
 
3431 rajveer 9042 
  def validate(self):
9043 
    return
9044 
 
9045 
 
3427 chandransh 9046 
  def __repr__(self):
9047 
    L = ['%s=%r' % (key, value)
9048 
      for key, value in self.__dict__.iteritems()]
9049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9050 
 
9051 
  def __eq__(self, other):
9052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9053 
 
9054 
  def __ne__(self, other):
9055 
    return not (self == other)
9056 
 
9057 
class getOrdersByShippingDate_result:
9058 
  """
9059 
  Attributes:
9060 
   - success
9061 
   - ex
9062 
  """
9063 
 
9064 
  thrift_spec = (
9065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9067 
  )
9068 
 
9069 
  def __init__(self, success=None, ex=None,):
9070 
    self.success = success
9071 
    self.ex = ex
9072 
 
9073 
  def read(self, iprot):
9074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9076 
      return
9077 
    iprot.readStructBegin()
9078 
    while True:
9079 
      (fname, ftype, fid) = iprot.readFieldBegin()
9080 
      if ftype == TType.STOP:
9081 
        break
9082 
      if fid == 0:
9083 
        if ftype == TType.LIST:
9084 
          self.success = []
5031 varun.gupt 9085 
          (_etype122, _size119) = iprot.readListBegin()
9086 
          for _i123 in xrange(_size119):
9087 
            _elem124 = Order()
9088 
            _elem124.read(iprot)
9089 
            self.success.append(_elem124)
3427 chandransh 9090 
          iprot.readListEnd()
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
9108 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9109 
    if self.success is not None:
3427 chandransh 9110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9112 
      for iter125 in self.success:
9113 
        iter125.write(oprot)
3427 chandransh 9114 
      oprot.writeListEnd()
9115 
      oprot.writeFieldEnd()
3431 rajveer 9116 
    if self.ex is not None:
3427 chandransh 9117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9118 
      self.ex.write(oprot)
9119 
      oprot.writeFieldEnd()
9120 
    oprot.writeFieldStop()
9121 
    oprot.writeStructEnd()
9122 
 
3431 rajveer 9123 
  def validate(self):
9124 
    return
9125 
 
9126 
 
3427 chandransh 9127 
  def __repr__(self):
9128 
    L = ['%s=%r' % (key, value)
9129 
      for key, value in self.__dict__.iteritems()]
9130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9131 
 
9132 
  def __eq__(self, other):
9133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9134 
 
9135 
  def __ne__(self, other):
9136 
    return not (self == other)
9137 
 
1382 varun.gupt 9138 
class getReturnableOrdersForCustomer_args:
9139 
  """
9140 
  Attributes:
9141 
   - customer_id
9142 
   - limit
9143 
  """
9144 
 
9145 
  thrift_spec = (
9146 
    None, # 0
9147 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9148 
    (2, TType.I64, 'limit', None, None, ), # 2
9149 
  )
9150 
 
9151 
  def __init__(self, customer_id=None, limit=None,):
9152 
    self.customer_id = customer_id
9153 
    self.limit = limit
9154 
 
9155 
  def read(self, iprot):
9156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9158 
      return
9159 
    iprot.readStructBegin()
9160 
    while True:
9161 
      (fname, ftype, fid) = iprot.readFieldBegin()
9162 
      if ftype == TType.STOP:
9163 
        break
9164 
      if fid == 1:
9165 
        if ftype == TType.I64:
9166 
          self.customer_id = iprot.readI64();
9167 
        else:
9168 
          iprot.skip(ftype)
9169 
      elif fid == 2:
9170 
        if ftype == TType.I64:
9171 
          self.limit = iprot.readI64();
9172 
        else:
9173 
          iprot.skip(ftype)
9174 
      else:
9175 
        iprot.skip(ftype)
9176 
      iprot.readFieldEnd()
9177 
    iprot.readStructEnd()
9178 
 
9179 
  def write(self, oprot):
9180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9182 
      return
9183 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9184 
    if self.customer_id is not None:
1382 varun.gupt 9185 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9186 
      oprot.writeI64(self.customer_id)
9187 
      oprot.writeFieldEnd()
3431 rajveer 9188 
    if self.limit is not None:
1382 varun.gupt 9189 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9190 
      oprot.writeI64(self.limit)
9191 
      oprot.writeFieldEnd()
9192 
    oprot.writeFieldStop()
9193 
    oprot.writeStructEnd()
9194 
 
3431 rajveer 9195 
  def validate(self):
9196 
    return
9197 
 
9198 
 
1382 varun.gupt 9199 
  def __repr__(self):
9200 
    L = ['%s=%r' % (key, value)
9201 
      for key, value in self.__dict__.iteritems()]
9202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9203 
 
9204 
  def __eq__(self, other):
9205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9206 
 
9207 
  def __ne__(self, other):
9208 
    return not (self == other)
9209 
 
9210 
class getReturnableOrdersForCustomer_result:
9211 
  """
9212 
  Attributes:
9213 
   - success
9214 
   - ex
9215 
  """
9216 
 
9217 
  thrift_spec = (
9218 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9219 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9220 
  )
9221 
 
9222 
  def __init__(self, success=None, ex=None,):
9223 
    self.success = success
9224 
    self.ex = ex
9225 
 
9226 
  def read(self, iprot):
9227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9229 
      return
9230 
    iprot.readStructBegin()
9231 
    while True:
9232 
      (fname, ftype, fid) = iprot.readFieldBegin()
9233 
      if ftype == TType.STOP:
9234 
        break
9235 
      if fid == 0:
9236 
        if ftype == TType.LIST:
9237 
          self.success = []
5031 varun.gupt 9238 
          (_etype129, _size126) = iprot.readListBegin()
9239 
          for _i130 in xrange(_size126):
9240 
            _elem131 = iprot.readI64();
9241 
            self.success.append(_elem131)
1382 varun.gupt 9242 
          iprot.readListEnd()
9243 
        else:
9244 
          iprot.skip(ftype)
9245 
      elif fid == 1:
9246 
        if ftype == TType.STRUCT:
9247 
          self.ex = TransactionServiceException()
9248 
          self.ex.read(iprot)
9249 
        else:
9250 
          iprot.skip(ftype)
9251 
      else:
9252 
        iprot.skip(ftype)
9253 
      iprot.readFieldEnd()
9254 
    iprot.readStructEnd()
9255 
 
9256 
  def write(self, oprot):
9257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9259 
      return
9260 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9261 
    if self.success is not None:
1382 varun.gupt 9262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9263 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9264 
      for iter132 in self.success:
9265 
        oprot.writeI64(iter132)
1382 varun.gupt 9266 
      oprot.writeListEnd()
9267 
      oprot.writeFieldEnd()
3431 rajveer 9268 
    if self.ex is not None:
1382 varun.gupt 9269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9270 
      self.ex.write(oprot)
9271 
      oprot.writeFieldEnd()
9272 
    oprot.writeFieldStop()
9273 
    oprot.writeStructEnd()
9274 
 
3431 rajveer 9275 
  def validate(self):
9276 
    return
9277 
 
9278 
 
1382 varun.gupt 9279 
  def __repr__(self):
9280 
    L = ['%s=%r' % (key, value)
9281 
      for key, value in self.__dict__.iteritems()]
9282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9283 
 
9284 
  def __eq__(self, other):
9285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9286 
 
9287 
  def __ne__(self, other):
9288 
    return not (self == other)
9289 
 
9290 
class getCancellableOrdersForCustomer_args:
9291 
  """
9292 
  Attributes:
9293 
   - customer_id
9294 
   - limit
9295 
  """
9296 
 
9297 
  thrift_spec = (
9298 
    None, # 0
9299 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9300 
    (2, TType.I64, 'limit', None, None, ), # 2
9301 
  )
9302 
 
9303 
  def __init__(self, customer_id=None, limit=None,):
9304 
    self.customer_id = customer_id
9305 
    self.limit = limit
9306 
 
9307 
  def read(self, iprot):
9308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9310 
      return
9311 
    iprot.readStructBegin()
9312 
    while True:
9313 
      (fname, ftype, fid) = iprot.readFieldBegin()
9314 
      if ftype == TType.STOP:
9315 
        break
9316 
      if fid == 1:
9317 
        if ftype == TType.I64:
9318 
          self.customer_id = iprot.readI64();
9319 
        else:
9320 
          iprot.skip(ftype)
9321 
      elif fid == 2:
9322 
        if ftype == TType.I64:
9323 
          self.limit = iprot.readI64();
9324 
        else:
9325 
          iprot.skip(ftype)
9326 
      else:
9327 
        iprot.skip(ftype)
9328 
      iprot.readFieldEnd()
9329 
    iprot.readStructEnd()
9330 
 
9331 
  def write(self, oprot):
9332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9334 
      return
9335 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9336 
    if self.customer_id is not None:
1382 varun.gupt 9337 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9338 
      oprot.writeI64(self.customer_id)
9339 
      oprot.writeFieldEnd()
3431 rajveer 9340 
    if self.limit is not None:
1382 varun.gupt 9341 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9342 
      oprot.writeI64(self.limit)
9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
3431 rajveer 9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
1382 varun.gupt 9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
9362 
class getCancellableOrdersForCustomer_result:
9363 
  """
9364 
  Attributes:
9365 
   - success
9366 
   - ex
9367 
  """
9368 
 
9369 
  thrift_spec = (
9370 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9372 
  )
9373 
 
9374 
  def __init__(self, success=None, ex=None,):
9375 
    self.success = success
9376 
    self.ex = ex
9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 0:
9388 
        if ftype == TType.LIST:
9389 
          self.success = []
5031 varun.gupt 9390 
          (_etype136, _size133) = iprot.readListBegin()
9391 
          for _i137 in xrange(_size133):
9392 
            _elem138 = iprot.readI64();
9393 
            self.success.append(_elem138)
1382 varun.gupt 9394 
          iprot.readListEnd()
9395 
        else:
9396 
          iprot.skip(ftype)
9397 
      elif fid == 1:
9398 
        if ftype == TType.STRUCT:
9399 
          self.ex = TransactionServiceException()
9400 
          self.ex.read(iprot)
9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
9412 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9413 
    if self.success is not None:
1382 varun.gupt 9414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9415 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9416 
      for iter139 in self.success:
9417 
        oprot.writeI64(iter139)
1382 varun.gupt 9418 
      oprot.writeListEnd()
9419 
      oprot.writeFieldEnd()
3431 rajveer 9420 
    if self.ex is not None:
1382 varun.gupt 9421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9422 
      self.ex.write(oprot)
9423 
      oprot.writeFieldEnd()
9424 
    oprot.writeFieldStop()
9425 
    oprot.writeStructEnd()
9426 
 
3431 rajveer 9427 
  def validate(self):
9428 
    return
9429 
 
9430 
 
1382 varun.gupt 9431 
  def __repr__(self):
9432 
    L = ['%s=%r' % (key, value)
9433 
      for key, value in self.__dict__.iteritems()]
9434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9435 
 
9436 
  def __eq__(self, other):
9437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9438 
 
9439 
  def __ne__(self, other):
9440 
    return not (self == other)
9441 
 
483 rajveer 9442 
class changeOrderStatus_args:
94 ashish 9443 
  """
9444 
  Attributes:
483 rajveer 9445 
   - orderId
9446 
   - status
9447 
   - description
94 ashish 9448 
  """
9449 
 
9450 
  thrift_spec = (
9451 
    None, # 0
483 rajveer 9452 
    (1, TType.I64, 'orderId', None, None, ), # 1
9453 
    (2, TType.I32, 'status', None, None, ), # 2
9454 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9455 
  )
9456 
 
483 rajveer 9457 
  def __init__(self, orderId=None, status=None, description=None,):
9458 
    self.orderId = orderId
9459 
    self.status = status
9460 
    self.description = description
94 ashish 9461 
 
9462 
  def read(self, iprot):
9463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9465 
      return
9466 
    iprot.readStructBegin()
9467 
    while True:
9468 
      (fname, ftype, fid) = iprot.readFieldBegin()
9469 
      if ftype == TType.STOP:
9470 
        break
9471 
      if fid == 1:
9472 
        if ftype == TType.I64:
483 rajveer 9473 
          self.orderId = iprot.readI64();
94 ashish 9474 
        else:
9475 
          iprot.skip(ftype)
9476 
      elif fid == 2:
483 rajveer 9477 
        if ftype == TType.I32:
9478 
          self.status = iprot.readI32();
94 ashish 9479 
        else:
9480 
          iprot.skip(ftype)
483 rajveer 9481 
      elif fid == 3:
9482 
        if ftype == TType.STRING:
9483 
          self.description = iprot.readString();
9484 
        else:
9485 
          iprot.skip(ftype)
94 ashish 9486 
      else:
9487 
        iprot.skip(ftype)
9488 
      iprot.readFieldEnd()
9489 
    iprot.readStructEnd()
9490 
 
9491 
  def write(self, oprot):
9492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9494 
      return
483 rajveer 9495 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9496 
    if self.orderId is not None:
483 rajveer 9497 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9498 
      oprot.writeI64(self.orderId)
94 ashish 9499 
      oprot.writeFieldEnd()
3431 rajveer 9500 
    if self.status is not None:
483 rajveer 9501 
      oprot.writeFieldBegin('status', TType.I32, 2)
9502 
      oprot.writeI32(self.status)
94 ashish 9503 
      oprot.writeFieldEnd()
3431 rajveer 9504 
    if self.description is not None:
483 rajveer 9505 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9506 
      oprot.writeString(self.description)
9507 
      oprot.writeFieldEnd()
94 ashish 9508 
    oprot.writeFieldStop()
9509 
    oprot.writeStructEnd()
9510 
 
3431 rajveer 9511 
  def validate(self):
9512 
    return
9513 
 
9514 
 
94 ashish 9515 
  def __repr__(self):
9516 
    L = ['%s=%r' % (key, value)
9517 
      for key, value in self.__dict__.iteritems()]
9518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9519 
 
9520 
  def __eq__(self, other):
9521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9522 
 
9523 
  def __ne__(self, other):
9524 
    return not (self == other)
9525 
 
483 rajveer 9526 
class changeOrderStatus_result:
94 ashish 9527 
  """
9528 
  Attributes:
9529 
   - success
9530 
   - ex
9531 
  """
9532 
 
9533 
  thrift_spec = (
9534 
    (0, TType.BOOL, 'success', None, None, ), # 0
9535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9536 
  )
9537 
 
9538 
  def __init__(self, success=None, ex=None,):
9539 
    self.success = success
9540 
    self.ex = ex
9541 
 
9542 
  def read(self, iprot):
9543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9545 
      return
9546 
    iprot.readStructBegin()
9547 
    while True:
9548 
      (fname, ftype, fid) = iprot.readFieldBegin()
9549 
      if ftype == TType.STOP:
9550 
        break
9551 
      if fid == 0:
9552 
        if ftype == TType.BOOL:
9553 
          self.success = iprot.readBool();
9554 
        else:
9555 
          iprot.skip(ftype)
9556 
      elif fid == 1:
9557 
        if ftype == TType.STRUCT:
9558 
          self.ex = TransactionServiceException()
9559 
          self.ex.read(iprot)
9560 
        else:
9561 
          iprot.skip(ftype)
9562 
      else:
9563 
        iprot.skip(ftype)
9564 
      iprot.readFieldEnd()
9565 
    iprot.readStructEnd()
9566 
 
9567 
  def write(self, oprot):
9568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9570 
      return
483 rajveer 9571 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9572 
    if self.success is not None:
94 ashish 9573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9574 
      oprot.writeBool(self.success)
9575 
      oprot.writeFieldEnd()
3431 rajveer 9576 
    if self.ex is not None:
94 ashish 9577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9578 
      self.ex.write(oprot)
9579 
      oprot.writeFieldEnd()
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
3431 rajveer 9583 
  def validate(self):
9584 
    return
9585 
 
9586 
 
94 ashish 9587 
  def __repr__(self):
9588 
    L = ['%s=%r' % (key, value)
9589 
      for key, value in self.__dict__.iteritems()]
9590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9591 
 
9592 
  def __eq__(self, other):
9593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9594 
 
9595 
  def __ne__(self, other):
9596 
    return not (self == other)
9597 
 
3064 chandransh 9598 
class getOrdersForTransaction_args:
494 rajveer 9599 
  """
9600 
  Attributes:
3064 chandransh 9601 
   - transactionId
9602 
   - customerId
494 rajveer 9603 
  """
9604 
 
9605 
  thrift_spec = (
9606 
    None, # 0
3064 chandransh 9607 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9608 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9609 
  )
9610 
 
3064 chandransh 9611 
  def __init__(self, transactionId=None, customerId=None,):
9612 
    self.transactionId = transactionId
9613 
    self.customerId = customerId
494 rajveer 9614 
 
9615 
  def read(self, iprot):
9616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9618 
      return
9619 
    iprot.readStructBegin()
9620 
    while True:
9621 
      (fname, ftype, fid) = iprot.readFieldBegin()
9622 
      if ftype == TType.STOP:
9623 
        break
9624 
      if fid == 1:
9625 
        if ftype == TType.I64:
3064 chandransh 9626 
          self.transactionId = iprot.readI64();
494 rajveer 9627 
        else:
9628 
          iprot.skip(ftype)
9629 
      elif fid == 2:
3064 chandransh 9630 
        if ftype == TType.I64:
9631 
          self.customerId = iprot.readI64();
494 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('getOrdersForTransaction_args')
3431 rajveer 9644 
    if self.transactionId is not None:
3064 chandransh 9645 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9646 
      oprot.writeI64(self.transactionId)
494 rajveer 9647 
      oprot.writeFieldEnd()
3431 rajveer 9648 
    if self.customerId is not None:
3064 chandransh 9649 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9650 
      oprot.writeI64(self.customerId)
494 rajveer 9651 
      oprot.writeFieldEnd()
9652 
    oprot.writeFieldStop()
9653 
    oprot.writeStructEnd()
9654 
 
3431 rajveer 9655 
  def validate(self):
9656 
    return
9657 
 
9658 
 
494 rajveer 9659 
  def __repr__(self):
9660 
    L = ['%s=%r' % (key, value)
9661 
      for key, value in self.__dict__.iteritems()]
9662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9663 
 
9664 
  def __eq__(self, other):
9665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9666 
 
9667 
  def __ne__(self, other):
9668 
    return not (self == other)
9669 
 
3064 chandransh 9670 
class getOrdersForTransaction_result:
494 rajveer 9671 
  """
9672 
  Attributes:
9673 
   - success
9674 
   - ex
9675 
  """
9676 
 
9677 
  thrift_spec = (
3064 chandransh 9678 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9680 
  )
9681 
 
9682 
  def __init__(self, success=None, ex=None,):
9683 
    self.success = success
9684 
    self.ex = ex
9685 
 
9686 
  def read(self, iprot):
9687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9689 
      return
9690 
    iprot.readStructBegin()
9691 
    while True:
9692 
      (fname, ftype, fid) = iprot.readFieldBegin()
9693 
      if ftype == TType.STOP:
9694 
        break
9695 
      if fid == 0:
3064 chandransh 9696 
        if ftype == TType.LIST:
9697 
          self.success = []
5031 varun.gupt 9698 
          (_etype143, _size140) = iprot.readListBegin()
9699 
          for _i144 in xrange(_size140):
9700 
            _elem145 = Order()
9701 
            _elem145.read(iprot)
9702 
            self.success.append(_elem145)
3064 chandransh 9703 
          iprot.readListEnd()
494 rajveer 9704 
        else:
9705 
          iprot.skip(ftype)
9706 
      elif fid == 1:
9707 
        if ftype == TType.STRUCT:
9708 
          self.ex = TransactionServiceException()
9709 
          self.ex.read(iprot)
9710 
        else:
9711 
          iprot.skip(ftype)
9712 
      else:
9713 
        iprot.skip(ftype)
9714 
      iprot.readFieldEnd()
9715 
    iprot.readStructEnd()
9716 
 
9717 
  def write(self, oprot):
9718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9720 
      return
3064 chandransh 9721 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9722 
    if self.success is not None:
3064 chandransh 9723 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9724 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9725 
      for iter146 in self.success:
9726 
        iter146.write(oprot)
3064 chandransh 9727 
      oprot.writeListEnd()
494 rajveer 9728 
      oprot.writeFieldEnd()
3431 rajveer 9729 
    if self.ex is not None:
494 rajveer 9730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9731 
      self.ex.write(oprot)
9732 
      oprot.writeFieldEnd()
9733 
    oprot.writeFieldStop()
9734 
    oprot.writeStructEnd()
9735 
 
3431 rajveer 9736 
  def validate(self):
9737 
    return
9738 
 
9739 
 
494 rajveer 9740 
  def __repr__(self):
9741 
    L = ['%s=%r' % (key, value)
9742 
      for key, value in self.__dict__.iteritems()]
9743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9744 
 
9745 
  def __eq__(self, other):
9746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9747 
 
9748 
  def __ne__(self, other):
9749 
    return not (self == other)
9750 
 
3064 chandransh 9751 
class getOrdersForCustomer_args:
1149 chandransh 9752 
  """
9753 
  Attributes:
3064 chandransh 9754 
   - customerId
9755 
   - from_date
9756 
   - to_date
9757 
   - statuses
1149 chandransh 9758 
  """
9759 
 
9760 
  thrift_spec = (
9761 
    None, # 0
3064 chandransh 9762 
    (1, TType.I64, 'customerId', None, None, ), # 1
9763 
    (2, TType.I64, 'from_date', None, None, ), # 2
9764 
    (3, TType.I64, 'to_date', None, None, ), # 3
9765 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9766 
  )
9767 
 
3064 chandransh 9768 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9769 
    self.customerId = customerId
9770 
    self.from_date = from_date
9771 
    self.to_date = to_date
9772 
    self.statuses = statuses
1149 chandransh 9773 
 
9774 
  def read(self, iprot):
9775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9777 
      return
9778 
    iprot.readStructBegin()
9779 
    while True:
9780 
      (fname, ftype, fid) = iprot.readFieldBegin()
9781 
      if ftype == TType.STOP:
9782 
        break
9783 
      if fid == 1:
9784 
        if ftype == TType.I64:
3064 chandransh 9785 
          self.customerId = iprot.readI64();
1149 chandransh 9786 
        else:
9787 
          iprot.skip(ftype)
9788 
      elif fid == 2:
9789 
        if ftype == TType.I64:
3064 chandransh 9790 
          self.from_date = iprot.readI64();
1149 chandransh 9791 
        else:
9792 
          iprot.skip(ftype)
2783 chandransh 9793 
      elif fid == 3:
9794 
        if ftype == TType.I64:
3064 chandransh 9795 
          self.to_date = iprot.readI64();
2783 chandransh 9796 
        else:
9797 
          iprot.skip(ftype)
9798 
      elif fid == 4:
3064 chandransh 9799 
        if ftype == TType.LIST:
9800 
          self.statuses = []
5031 varun.gupt 9801 
          (_etype150, _size147) = iprot.readListBegin()
9802 
          for _i151 in xrange(_size147):
9803 
            _elem152 = iprot.readI32();
9804 
            self.statuses.append(_elem152)
3064 chandransh 9805 
          iprot.readListEnd()
2783 chandransh 9806 
        else:
9807 
          iprot.skip(ftype)
1149 chandransh 9808 
      else:
9809 
        iprot.skip(ftype)
9810 
      iprot.readFieldEnd()
9811 
    iprot.readStructEnd()
9812 
 
9813 
  def write(self, oprot):
9814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9816 
      return
3064 chandransh 9817 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9818 
    if self.customerId is not None:
3064 chandransh 9819 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9820 
      oprot.writeI64(self.customerId)
1149 chandransh 9821 
      oprot.writeFieldEnd()
3431 rajveer 9822 
    if self.from_date is not None:
3064 chandransh 9823 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9824 
      oprot.writeI64(self.from_date)
1149 chandransh 9825 
      oprot.writeFieldEnd()
3431 rajveer 9826 
    if self.to_date is not None:
3064 chandransh 9827 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9828 
      oprot.writeI64(self.to_date)
2783 chandransh 9829 
      oprot.writeFieldEnd()
3431 rajveer 9830 
    if self.statuses is not None:
3064 chandransh 9831 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9832 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9833 
      for iter153 in self.statuses:
9834 
        oprot.writeI32(iter153)
3064 chandransh 9835 
      oprot.writeListEnd()
2783 chandransh 9836 
      oprot.writeFieldEnd()
1149 chandransh 9837 
    oprot.writeFieldStop()
9838 
    oprot.writeStructEnd()
9839 
 
3431 rajveer 9840 
  def validate(self):
9841 
    return
9842 
 
9843 
 
1149 chandransh 9844 
  def __repr__(self):
9845 
    L = ['%s=%r' % (key, value)
9846 
      for key, value in self.__dict__.iteritems()]
9847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9848 
 
9849 
  def __eq__(self, other):
9850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9851 
 
9852 
  def __ne__(self, other):
9853 
    return not (self == other)
9854 
 
3064 chandransh 9855 
class getOrdersForCustomer_result:
1149 chandransh 9856 
  """
9857 
  Attributes:
9858 
   - success
9859 
   - ex
9860 
  """
9861 
 
9862 
  thrift_spec = (
3064 chandransh 9863 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9865 
  )
9866 
 
9867 
  def __init__(self, success=None, ex=None,):
9868 
    self.success = success
9869 
    self.ex = ex
9870 
 
9871 
  def read(self, iprot):
9872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9874 
      return
9875 
    iprot.readStructBegin()
9876 
    while True:
9877 
      (fname, ftype, fid) = iprot.readFieldBegin()
9878 
      if ftype == TType.STOP:
9879 
        break
9880 
      if fid == 0:
3064 chandransh 9881 
        if ftype == TType.LIST:
9882 
          self.success = []
5031 varun.gupt 9883 
          (_etype157, _size154) = iprot.readListBegin()
9884 
          for _i158 in xrange(_size154):
9885 
            _elem159 = Order()
9886 
            _elem159.read(iprot)
9887 
            self.success.append(_elem159)
3064 chandransh 9888 
          iprot.readListEnd()
1149 chandransh 9889 
        else:
9890 
          iprot.skip(ftype)
9891 
      elif fid == 1:
9892 
        if ftype == TType.STRUCT:
9893 
          self.ex = TransactionServiceException()
9894 
          self.ex.read(iprot)
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      else:
9898 
        iprot.skip(ftype)
9899 
      iprot.readFieldEnd()
9900 
    iprot.readStructEnd()
9901 
 
9902 
  def write(self, oprot):
9903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9905 
      return
3064 chandransh 9906 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9907 
    if self.success is not None:
3064 chandransh 9908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9910 
      for iter160 in self.success:
9911 
        iter160.write(oprot)
3064 chandransh 9912 
      oprot.writeListEnd()
1149 chandransh 9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.ex is not None:
1149 chandransh 9915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9916 
      self.ex.write(oprot)
9917 
      oprot.writeFieldEnd()
9918 
    oprot.writeFieldStop()
9919 
    oprot.writeStructEnd()
9920 
 
3431 rajveer 9921 
  def validate(self):
9922 
    return
9923 
 
9924 
 
1149 chandransh 9925 
  def __repr__(self):
9926 
    L = ['%s=%r' % (key, value)
9927 
      for key, value in self.__dict__.iteritems()]
9928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9929 
 
9930 
  def __eq__(self, other):
9931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9932 
 
9933 
  def __ne__(self, other):
9934 
    return not (self == other)
9935 
 
3064 chandransh 9936 
class createOrder_args:
921 rajveer 9937 
  """
9938 
  Attributes:
3064 chandransh 9939 
   - order
921 rajveer 9940 
  """
9941 
 
9942 
  thrift_spec = (
9943 
    None, # 0
3064 chandransh 9944 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9945 
  )
9946 
 
3064 chandransh 9947 
  def __init__(self, order=None,):
9948 
    self.order = order
921 rajveer 9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 1:
3064 chandransh 9960 
        if ftype == TType.STRUCT:
9961 
          self.order = Order()
9962 
          self.order.read(iprot)
921 rajveer 9963 
        else:
9964 
          iprot.skip(ftype)
9965 
      else:
9966 
        iprot.skip(ftype)
9967 
      iprot.readFieldEnd()
9968 
    iprot.readStructEnd()
9969 
 
9970 
  def write(self, oprot):
9971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9973 
      return
3064 chandransh 9974 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9975 
    if self.order is not None:
3064 chandransh 9976 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9977 
      self.order.write(oprot)
921 rajveer 9978 
      oprot.writeFieldEnd()
9979 
    oprot.writeFieldStop()
9980 
    oprot.writeStructEnd()
9981 
 
3431 rajveer 9982 
  def validate(self):
9983 
    return
9984 
 
9985 
 
921 rajveer 9986 
  def __repr__(self):
9987 
    L = ['%s=%r' % (key, value)
9988 
      for key, value in self.__dict__.iteritems()]
9989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9990 
 
9991 
  def __eq__(self, other):
9992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9993 
 
9994 
  def __ne__(self, other):
9995 
    return not (self == other)
9996 
 
3064 chandransh 9997 
class createOrder_result:
921 rajveer 9998 
  """
9999 
  Attributes:
10000 
   - success
10001 
   - ex
10002 
  """
10003 
 
10004 
  thrift_spec = (
3064 chandransh 10005 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10007 
  )
10008 
 
10009 
  def __init__(self, success=None, ex=None,):
10010 
    self.success = success
10011 
    self.ex = ex
10012 
 
10013 
  def read(self, iprot):
10014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10016 
      return
10017 
    iprot.readStructBegin()
10018 
    while True:
10019 
      (fname, ftype, fid) = iprot.readFieldBegin()
10020 
      if ftype == TType.STOP:
10021 
        break
10022 
      if fid == 0:
3064 chandransh 10023 
        if ftype == TType.I64:
10024 
          self.success = iprot.readI64();
921 rajveer 10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      elif fid == 1:
10028 
        if ftype == TType.STRUCT:
10029 
          self.ex = TransactionServiceException()
10030 
          self.ex.read(iprot)
10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      else:
10034 
        iprot.skip(ftype)
10035 
      iprot.readFieldEnd()
10036 
    iprot.readStructEnd()
10037 
 
10038 
  def write(self, oprot):
10039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10041 
      return
3064 chandransh 10042 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10043 
    if self.success is not None:
3064 chandransh 10044 
      oprot.writeFieldBegin('success', TType.I64, 0)
10045 
      oprot.writeI64(self.success)
921 rajveer 10046 
      oprot.writeFieldEnd()
3431 rajveer 10047 
    if self.ex is not None:
921 rajveer 10048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10049 
      self.ex.write(oprot)
10050 
      oprot.writeFieldEnd()
10051 
    oprot.writeFieldStop()
10052 
    oprot.writeStructEnd()
10053 
 
3431 rajveer 10054 
  def validate(self):
10055 
    return
10056 
 
10057 
 
921 rajveer 10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
3064 chandransh 10069 
class getOrder_args:
921 rajveer 10070 
  """
10071 
  Attributes:
3064 chandransh 10072 
   - id
921 rajveer 10073 
  """
10074 
 
10075 
  thrift_spec = (
10076 
    None, # 0
3064 chandransh 10077 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10078 
  )
10079 
 
3064 chandransh 10080 
  def __init__(self, id=None,):
10081 
    self.id = id
921 rajveer 10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 1:
10093 
        if ftype == TType.I64:
3064 chandransh 10094 
          self.id = iprot.readI64();
921 rajveer 10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
3064 chandransh 10106 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10107 
    if self.id is not None:
3064 chandransh 10108 
      oprot.writeFieldBegin('id', TType.I64, 1)
10109 
      oprot.writeI64(self.id)
921 rajveer 10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
3431 rajveer 10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
921 rajveer 10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
3064 chandransh 10129 
class getOrder_result:
921 rajveer 10130 
  """
10131 
  Attributes:
10132 
   - success
10133 
   - ex
10134 
  """
10135 
 
10136 
  thrift_spec = (
3064 chandransh 10137 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10139 
  )
10140 
 
10141 
  def __init__(self, success=None, ex=None,):
10142 
    self.success = success
10143 
    self.ex = ex
10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      if fid == 0:
3064 chandransh 10155 
        if ftype == TType.STRUCT:
10156 
          self.success = Order()
10157 
          self.success.read(iprot)
921 rajveer 10158 
        else:
10159 
          iprot.skip(ftype)
10160 
      elif fid == 1:
10161 
        if ftype == TType.STRUCT:
10162 
          self.ex = TransactionServiceException()
10163 
          self.ex.read(iprot)
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      else:
10167 
        iprot.skip(ftype)
10168 
      iprot.readFieldEnd()
10169 
    iprot.readStructEnd()
10170 
 
10171 
  def write(self, oprot):
10172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10174 
      return
3064 chandransh 10175 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10176 
    if self.success is not None:
3064 chandransh 10177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10178 
      self.success.write(oprot)
921 rajveer 10179 
      oprot.writeFieldEnd()
3431 rajveer 10180 
    if self.ex is not None:
921 rajveer 10181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10182 
      self.ex.write(oprot)
10183 
      oprot.writeFieldEnd()
10184 
    oprot.writeFieldStop()
10185 
    oprot.writeStructEnd()
10186 
 
3431 rajveer 10187 
  def validate(self):
10188 
    return
10189 
 
10190 
 
921 rajveer 10191 
  def __repr__(self):
10192 
    L = ['%s=%r' % (key, value)
10193 
      for key, value in self.__dict__.iteritems()]
10194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10195 
 
10196 
  def __eq__(self, other):
10197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10198 
 
10199 
  def __ne__(self, other):
10200 
    return not (self == other)
10201 
 
3064 chandransh 10202 
class getLineItemsForOrder_args:
94 ashish 10203 
  """
10204 
  Attributes:
3064 chandransh 10205 
   - orderId
94 ashish 10206 
  """
10207 
 
10208 
  thrift_spec = (
10209 
    None, # 0
3064 chandransh 10210 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10211 
  )
10212 
 
3064 chandransh 10213 
  def __init__(self, orderId=None,):
10214 
    self.orderId = orderId
94 ashish 10215 
 
10216 
  def read(self, iprot):
10217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10219 
      return
10220 
    iprot.readStructBegin()
10221 
    while True:
10222 
      (fname, ftype, fid) = iprot.readFieldBegin()
10223 
      if ftype == TType.STOP:
10224 
        break
10225 
      if fid == 1:
10226 
        if ftype == TType.I64:
3064 chandransh 10227 
          self.orderId = iprot.readI64();
94 ashish 10228 
        else:
10229 
          iprot.skip(ftype)
10230 
      else:
10231 
        iprot.skip(ftype)
10232 
      iprot.readFieldEnd()
10233 
    iprot.readStructEnd()
10234 
 
10235 
  def write(self, oprot):
10236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10238 
      return
3064 chandransh 10239 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10240 
    if self.orderId is not None:
3064 chandransh 10241 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10242 
      oprot.writeI64(self.orderId)
94 ashish 10243 
      oprot.writeFieldEnd()
10244 
    oprot.writeFieldStop()
10245 
    oprot.writeStructEnd()
10246 
 
3431 rajveer 10247 
  def validate(self):
10248 
    return
10249 
 
10250 
 
94 ashish 10251 
  def __repr__(self):
10252 
    L = ['%s=%r' % (key, value)
10253 
      for key, value in self.__dict__.iteritems()]
10254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10255 
 
10256 
  def __eq__(self, other):
10257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10258 
 
10259 
  def __ne__(self, other):
10260 
    return not (self == other)
10261 
 
3064 chandransh 10262 
class getLineItemsForOrder_result:
94 ashish 10263 
  """
10264 
  Attributes:
10265 
   - success
10266 
   - ex
10267 
  """
10268 
 
10269 
  thrift_spec = (
3064 chandransh 10270 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10272 
  )
10273 
 
10274 
  def __init__(self, success=None, ex=None,):
10275 
    self.success = success
10276 
    self.ex = ex
10277 
 
10278 
  def read(self, iprot):
10279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10281 
      return
10282 
    iprot.readStructBegin()
10283 
    while True:
10284 
      (fname, ftype, fid) = iprot.readFieldBegin()
10285 
      if ftype == TType.STOP:
10286 
        break
10287 
      if fid == 0:
483 rajveer 10288 
        if ftype == TType.LIST:
10289 
          self.success = []
5031 varun.gupt 10290 
          (_etype164, _size161) = iprot.readListBegin()
10291 
          for _i165 in xrange(_size161):
10292 
            _elem166 = LineItem()
10293 
            _elem166.read(iprot)
10294 
            self.success.append(_elem166)
483 rajveer 10295 
          iprot.readListEnd()
94 ashish 10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      elif fid == 1:
10299 
        if ftype == TType.STRUCT:
10300 
          self.ex = TransactionServiceException()
10301 
          self.ex.read(iprot)
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      else:
10305 
        iprot.skip(ftype)
10306 
      iprot.readFieldEnd()
10307 
    iprot.readStructEnd()
10308 
 
10309 
  def write(self, oprot):
10310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10312 
      return
3064 chandransh 10313 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10314 
    if self.success is not None:
483 rajveer 10315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10317 
      for iter167 in self.success:
10318 
        iter167.write(oprot)
483 rajveer 10319 
      oprot.writeListEnd()
94 ashish 10320 
      oprot.writeFieldEnd()
3431 rajveer 10321 
    if self.ex is not None:
94 ashish 10322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10323 
      self.ex.write(oprot)
10324 
      oprot.writeFieldEnd()
10325 
    oprot.writeFieldStop()
10326 
    oprot.writeStructEnd()
10327 
 
3431 rajveer 10328 
  def validate(self):
10329 
    return
10330 
 
10331 
 
94 ashish 10332 
  def __repr__(self):
10333 
    L = ['%s=%r' % (key, value)
10334 
      for key, value in self.__dict__.iteritems()]
10335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10336 
 
10337 
  def __eq__(self, other):
10338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10339 
 
10340 
  def __ne__(self, other):
10341 
    return not (self == other)
10342 
 
4999 phani.kuma 10343 
class getOrderList_args:
10344 
  """
10345 
  Attributes:
10346 
   - order_ids
10347 
  """
10348 
 
10349 
  thrift_spec = (
10350 
    None, # 0
10351 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10352 
  )
10353 
 
10354 
  def __init__(self, order_ids=None,):
10355 
    self.order_ids = order_ids
10356 
 
10357 
  def read(self, iprot):
10358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10360 
      return
10361 
    iprot.readStructBegin()
10362 
    while True:
10363 
      (fname, ftype, fid) = iprot.readFieldBegin()
10364 
      if ftype == TType.STOP:
10365 
        break
10366 
      if fid == 1:
10367 
        if ftype == TType.LIST:
10368 
          self.order_ids = []
5031 varun.gupt 10369 
          (_etype171, _size168) = iprot.readListBegin()
10370 
          for _i172 in xrange(_size168):
10371 
            _elem173 = iprot.readI64();
10372 
            self.order_ids.append(_elem173)
4999 phani.kuma 10373 
          iprot.readListEnd()
10374 
        else:
10375 
          iprot.skip(ftype)
10376 
      else:
10377 
        iprot.skip(ftype)
10378 
      iprot.readFieldEnd()
10379 
    iprot.readStructEnd()
10380 
 
10381 
  def write(self, oprot):
10382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10384 
      return
10385 
    oprot.writeStructBegin('getOrderList_args')
10386 
    if self.order_ids is not None:
10387 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10388 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10389 
      for iter174 in self.order_ids:
10390 
        oprot.writeI64(iter174)
4999 phani.kuma 10391 
      oprot.writeListEnd()
10392 
      oprot.writeFieldEnd()
10393 
    oprot.writeFieldStop()
10394 
    oprot.writeStructEnd()
10395 
 
10396 
  def validate(self):
10397 
    return
10398 
 
10399 
 
10400 
  def __repr__(self):
10401 
    L = ['%s=%r' % (key, value)
10402 
      for key, value in self.__dict__.iteritems()]
10403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10404 
 
10405 
  def __eq__(self, other):
10406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10407 
 
10408 
  def __ne__(self, other):
10409 
    return not (self == other)
10410 
 
10411 
class getOrderList_result:
10412 
  """
10413 
  Attributes:
10414 
   - success
10415 
  """
10416 
 
10417 
  thrift_spec = (
10418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10419 
  )
10420 
 
10421 
  def __init__(self, success=None,):
10422 
    self.success = success
10423 
 
10424 
  def read(self, iprot):
10425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10427 
      return
10428 
    iprot.readStructBegin()
10429 
    while True:
10430 
      (fname, ftype, fid) = iprot.readFieldBegin()
10431 
      if ftype == TType.STOP:
10432 
        break
10433 
      if fid == 0:
10434 
        if ftype == TType.LIST:
10435 
          self.success = []
5031 varun.gupt 10436 
          (_etype178, _size175) = iprot.readListBegin()
10437 
          for _i179 in xrange(_size175):
10438 
            _elem180 = Order()
10439 
            _elem180.read(iprot)
10440 
            self.success.append(_elem180)
4999 phani.kuma 10441 
          iprot.readListEnd()
10442 
        else:
10443 
          iprot.skip(ftype)
10444 
      else:
10445 
        iprot.skip(ftype)
10446 
      iprot.readFieldEnd()
10447 
    iprot.readStructEnd()
10448 
 
10449 
  def write(self, oprot):
10450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10452 
      return
10453 
    oprot.writeStructBegin('getOrderList_result')
10454 
    if self.success is not None:
10455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10456 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10457 
      for iter181 in self.success:
10458 
        iter181.write(oprot)
4999 phani.kuma 10459 
      oprot.writeListEnd()
10460 
      oprot.writeFieldEnd()
10461 
    oprot.writeFieldStop()
10462 
    oprot.writeStructEnd()
10463 
 
10464 
  def validate(self):
10465 
    return
10466 
 
10467 
 
10468 
  def __repr__(self):
10469 
    L = ['%s=%r' % (key, value)
10470 
      for key, value in self.__dict__.iteritems()]
10471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10472 
 
10473 
  def __eq__(self, other):
10474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10475 
 
10476 
  def __ne__(self, other):
10477 
    return not (self == other)
10478 
 
5386 phani.kuma 10479 
class getOrderListForVendor_args:
10480 
  """
10481 
  Attributes:
10482 
   - order_ids
10483 
   - vendorId
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    None, # 0
10488 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10489 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10490 
  )
10491 
 
10492 
  def __init__(self, order_ids=None, vendorId=None,):
10493 
    self.order_ids = order_ids
10494 
    self.vendorId = vendorId
10495 
 
10496 
  def read(self, iprot):
10497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10499 
      return
10500 
    iprot.readStructBegin()
10501 
    while True:
10502 
      (fname, ftype, fid) = iprot.readFieldBegin()
10503 
      if ftype == TType.STOP:
10504 
        break
10505 
      if fid == 1:
10506 
        if ftype == TType.LIST:
10507 
          self.order_ids = []
10508 
          (_etype185, _size182) = iprot.readListBegin()
10509 
          for _i186 in xrange(_size182):
10510 
            _elem187 = iprot.readI64();
10511 
            self.order_ids.append(_elem187)
10512 
          iprot.readListEnd()
10513 
        else:
10514 
          iprot.skip(ftype)
10515 
      elif fid == 2:
10516 
        if ftype == TType.I64:
10517 
          self.vendorId = iprot.readI64();
10518 
        else:
10519 
          iprot.skip(ftype)
10520 
      else:
10521 
        iprot.skip(ftype)
10522 
      iprot.readFieldEnd()
10523 
    iprot.readStructEnd()
10524 
 
10525 
  def write(self, oprot):
10526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10528 
      return
10529 
    oprot.writeStructBegin('getOrderListForVendor_args')
10530 
    if self.order_ids is not None:
10531 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10532 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10533 
      for iter188 in self.order_ids:
10534 
        oprot.writeI64(iter188)
10535 
      oprot.writeListEnd()
10536 
      oprot.writeFieldEnd()
10537 
    if self.vendorId is not None:
10538 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10539 
      oprot.writeI64(self.vendorId)
10540 
      oprot.writeFieldEnd()
10541 
    oprot.writeFieldStop()
10542 
    oprot.writeStructEnd()
10543 
 
10544 
  def validate(self):
10545 
    return
10546 
 
10547 
 
10548 
  def __repr__(self):
10549 
    L = ['%s=%r' % (key, value)
10550 
      for key, value in self.__dict__.iteritems()]
10551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10552 
 
10553 
  def __eq__(self, other):
10554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10555 
 
10556 
  def __ne__(self, other):
10557 
    return not (self == other)
10558 
 
10559 
class getOrderListForVendor_result:
10560 
  """
10561 
  Attributes:
10562 
   - success
10563 
  """
10564 
 
10565 
  thrift_spec = (
10566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10567 
  )
10568 
 
10569 
  def __init__(self, success=None,):
10570 
    self.success = success
10571 
 
10572 
  def read(self, iprot):
10573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10575 
      return
10576 
    iprot.readStructBegin()
10577 
    while True:
10578 
      (fname, ftype, fid) = iprot.readFieldBegin()
10579 
      if ftype == TType.STOP:
10580 
        break
10581 
      if fid == 0:
10582 
        if ftype == TType.LIST:
10583 
          self.success = []
10584 
          (_etype192, _size189) = iprot.readListBegin()
10585 
          for _i193 in xrange(_size189):
10586 
            _elem194 = Order()
10587 
            _elem194.read(iprot)
10588 
            self.success.append(_elem194)
10589 
          iprot.readListEnd()
10590 
        else:
10591 
          iprot.skip(ftype)
10592 
      else:
10593 
        iprot.skip(ftype)
10594 
      iprot.readFieldEnd()
10595 
    iprot.readStructEnd()
10596 
 
10597 
  def write(self, oprot):
10598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10600 
      return
10601 
    oprot.writeStructBegin('getOrderListForVendor_result')
10602 
    if self.success is not None:
10603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10605 
      for iter195 in self.success:
10606 
        iter195.write(oprot)
10607 
      oprot.writeListEnd()
10608 
      oprot.writeFieldEnd()
10609 
    oprot.writeFieldStop()
10610 
    oprot.writeStructEnd()
10611 
 
10612 
  def validate(self):
10613 
    return
10614 
 
10615 
 
10616 
  def __repr__(self):
10617 
    L = ['%s=%r' % (key, value)
10618 
      for key, value in self.__dict__.iteritems()]
10619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10620 
 
10621 
  def __eq__(self, other):
10622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10623 
 
10624 
  def __ne__(self, other):
10625 
    return not (self == other)
10626 
 
3064 chandransh 10627 
class getOrderForCustomer_args:
94 ashish 10628 
  """
10629 
  Attributes:
3064 chandransh 10630 
   - orderId
483 rajveer 10631 
   - customerId
94 ashish 10632 
  """
10633 
 
10634 
  thrift_spec = (
10635 
    None, # 0
3064 chandransh 10636 
    (1, TType.I64, 'orderId', None, None, ), # 1
10637 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10638 
  )
10639 
 
3064 chandransh 10640 
  def __init__(self, orderId=None, customerId=None,):
10641 
    self.orderId = orderId
483 rajveer 10642 
    self.customerId = customerId
94 ashish 10643 
 
10644 
  def read(self, iprot):
10645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10647 
      return
10648 
    iprot.readStructBegin()
10649 
    while True:
10650 
      (fname, ftype, fid) = iprot.readFieldBegin()
10651 
      if ftype == TType.STOP:
10652 
        break
10653 
      if fid == 1:
10654 
        if ftype == TType.I64:
3064 chandransh 10655 
          self.orderId = iprot.readI64();
94 ashish 10656 
        else:
10657 
          iprot.skip(ftype)
10658 
      elif fid == 2:
10659 
        if ftype == TType.I64:
3064 chandransh 10660 
          self.customerId = iprot.readI64();
94 ashish 10661 
        else:
10662 
          iprot.skip(ftype)
10663 
      else:
10664 
        iprot.skip(ftype)
10665 
      iprot.readFieldEnd()
10666 
    iprot.readStructEnd()
10667 
 
10668 
  def write(self, oprot):
10669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10671 
      return
3064 chandransh 10672 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10673 
    if self.orderId is not None:
3064 chandransh 10674 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10675 
      oprot.writeI64(self.orderId)
10676 
      oprot.writeFieldEnd()
3431 rajveer 10677 
    if self.customerId is not None:
3064 chandransh 10678 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10679 
      oprot.writeI64(self.customerId)
94 ashish 10680 
      oprot.writeFieldEnd()
10681 
    oprot.writeFieldStop()
10682 
    oprot.writeStructEnd()
10683 
 
3431 rajveer 10684 
  def validate(self):
10685 
    return
10686 
 
10687 
 
94 ashish 10688 
  def __repr__(self):
10689 
    L = ['%s=%r' % (key, value)
10690 
      for key, value in self.__dict__.iteritems()]
10691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10692 
 
10693 
  def __eq__(self, other):
10694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10695 
 
10696 
  def __ne__(self, other):
10697 
    return not (self == other)
10698 
 
3064 chandransh 10699 
class getOrderForCustomer_result:
94 ashish 10700 
  """
10701 
  Attributes:
10702 
   - success
10703 
   - ex
10704 
  """
10705 
 
10706 
  thrift_spec = (
3064 chandransh 10707 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10709 
  )
10710 
 
10711 
  def __init__(self, success=None, ex=None,):
10712 
    self.success = success
10713 
    self.ex = ex
10714 
 
10715 
  def read(self, iprot):
10716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10718 
      return
10719 
    iprot.readStructBegin()
10720 
    while True:
10721 
      (fname, ftype, fid) = iprot.readFieldBegin()
10722 
      if ftype == TType.STOP:
10723 
        break
10724 
      if fid == 0:
3064 chandransh 10725 
        if ftype == TType.STRUCT:
10726 
          self.success = Order()
10727 
          self.success.read(iprot)
94 ashish 10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      elif fid == 1:
10731 
        if ftype == TType.STRUCT:
10732 
          self.ex = TransactionServiceException()
10733 
          self.ex.read(iprot)
10734 
        else:
10735 
          iprot.skip(ftype)
10736 
      else:
10737 
        iprot.skip(ftype)
10738 
      iprot.readFieldEnd()
10739 
    iprot.readStructEnd()
10740 
 
10741 
  def write(self, oprot):
10742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10744 
      return
3064 chandransh 10745 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10746 
    if self.success is not None:
3064 chandransh 10747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10748 
      self.success.write(oprot)
94 ashish 10749 
      oprot.writeFieldEnd()
3431 rajveer 10750 
    if self.ex is not None:
94 ashish 10751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10752 
      self.ex.write(oprot)
10753 
      oprot.writeFieldEnd()
10754 
    oprot.writeFieldStop()
10755 
    oprot.writeStructEnd()
10756 
 
3431 rajveer 10757 
  def validate(self):
10758 
    return
10759 
 
10760 
 
94 ashish 10761 
  def __repr__(self):
10762 
    L = ['%s=%r' % (key, value)
10763 
      for key, value in self.__dict__.iteritems()]
10764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10765 
 
10766 
  def __eq__(self, other):
10767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10768 
 
10769 
  def __ne__(self, other):
10770 
    return not (self == other)
10771 
 
3064 chandransh 10772 
class getAlerts_args:
94 ashish 10773 
  """
10774 
  Attributes:
4394 rajveer 10775 
   - type
4444 rajveer 10776 
   - warehouseId
4394 rajveer 10777 
   - status
10778 
   - timestamp
94 ashish 10779 
  """
10780 
 
10781 
  thrift_spec = (
10782 
    None, # 0
4394 rajveer 10783 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10784 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10785 
    (3, TType.I64, 'status', None, None, ), # 3
10786 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10787 
  )
10788 
 
4444 rajveer 10789 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10790 
    self.type = type
4444 rajveer 10791 
    self.warehouseId = warehouseId
4394 rajveer 10792 
    self.status = status
10793 
    self.timestamp = timestamp
94 ashish 10794 
 
10795 
  def read(self, iprot):
10796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10798 
      return
10799 
    iprot.readStructBegin()
10800 
    while True:
10801 
      (fname, ftype, fid) = iprot.readFieldBegin()
10802 
      if ftype == TType.STOP:
10803 
        break
10804 
      if fid == 1:
3064 chandransh 10805 
        if ftype == TType.I64:
4394 rajveer 10806 
          self.type = iprot.readI64();
94 ashish 10807 
        else:
10808 
          iprot.skip(ftype)
3064 chandransh 10809 
      elif fid == 2:
4394 rajveer 10810 
        if ftype == TType.I64:
4444 rajveer 10811 
          self.warehouseId = iprot.readI64();
3064 chandransh 10812 
        else:
10813 
          iprot.skip(ftype)
4394 rajveer 10814 
      elif fid == 3:
10815 
        if ftype == TType.I64:
4444 rajveer 10816 
          self.status = iprot.readI64();
10817 
        else:
10818 
          iprot.skip(ftype)
10819 
      elif fid == 4:
10820 
        if ftype == TType.I64:
4394 rajveer 10821 
          self.timestamp = iprot.readI64();
10822 
        else:
10823 
          iprot.skip(ftype)
94 ashish 10824 
      else:
10825 
        iprot.skip(ftype)
10826 
      iprot.readFieldEnd()
10827 
    iprot.readStructEnd()
10828 
 
10829 
  def write(self, oprot):
10830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10832 
      return
3064 chandransh 10833 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10834 
    if self.type is not None:
10835 
      oprot.writeFieldBegin('type', TType.I64, 1)
10836 
      oprot.writeI64(self.type)
94 ashish 10837 
      oprot.writeFieldEnd()
4444 rajveer 10838 
    if self.warehouseId is not None:
10839 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10840 
      oprot.writeI64(self.warehouseId)
10841 
      oprot.writeFieldEnd()
4394 rajveer 10842 
    if self.status is not None:
4444 rajveer 10843 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10844 
      oprot.writeI64(self.status)
3064 chandransh 10845 
      oprot.writeFieldEnd()
4394 rajveer 10846 
    if self.timestamp is not None:
4444 rajveer 10847 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10848 
      oprot.writeI64(self.timestamp)
10849 
      oprot.writeFieldEnd()
94 ashish 10850 
    oprot.writeFieldStop()
10851 
    oprot.writeStructEnd()
10852 
 
3431 rajveer 10853 
  def validate(self):
10854 
    return
10855 
 
10856 
 
94 ashish 10857 
  def __repr__(self):
10858 
    L = ['%s=%r' % (key, value)
10859 
      for key, value in self.__dict__.iteritems()]
10860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10861 
 
10862 
  def __eq__(self, other):
10863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10864 
 
10865 
  def __ne__(self, other):
10866 
    return not (self == other)
10867 
 
3064 chandransh 10868 
class getAlerts_result:
94 ashish 10869 
  """
10870 
  Attributes:
10871 
   - success
10872 
  """
10873 
 
10874 
  thrift_spec = (
3064 chandransh 10875 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10876 
  )
10877 
 
3064 chandransh 10878 
  def __init__(self, success=None,):
94 ashish 10879 
    self.success = success
10880 
 
10881 
  def read(self, iprot):
10882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10884 
      return
10885 
    iprot.readStructBegin()
10886 
    while True:
10887 
      (fname, ftype, fid) = iprot.readFieldBegin()
10888 
      if ftype == TType.STOP:
10889 
        break
10890 
      if fid == 0:
3064 chandransh 10891 
        if ftype == TType.LIST:
10892 
          self.success = []
5386 phani.kuma 10893 
          (_etype199, _size196) = iprot.readListBegin()
10894 
          for _i200 in xrange(_size196):
10895 
            _elem201 = Alert()
10896 
            _elem201.read(iprot)
10897 
            self.success.append(_elem201)
3064 chandransh 10898 
          iprot.readListEnd()
94 ashish 10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      else:
10902 
        iprot.skip(ftype)
10903 
      iprot.readFieldEnd()
10904 
    iprot.readStructEnd()
10905 
 
10906 
  def write(self, oprot):
10907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10909 
      return
3064 chandransh 10910 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10911 
    if self.success is not None:
3064 chandransh 10912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10913 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10914 
      for iter202 in self.success:
10915 
        iter202.write(oprot)
3064 chandransh 10916 
      oprot.writeListEnd()
94 ashish 10917 
      oprot.writeFieldEnd()
10918 
    oprot.writeFieldStop()
10919 
    oprot.writeStructEnd()
10920 
 
3431 rajveer 10921 
  def validate(self):
10922 
    return
10923 
 
10924 
 
94 ashish 10925 
  def __repr__(self):
10926 
    L = ['%s=%r' % (key, value)
10927 
      for key, value in self.__dict__.iteritems()]
10928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10929 
 
10930 
  def __eq__(self, other):
10931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10932 
 
10933 
  def __ne__(self, other):
10934 
    return not (self == other)
10935 
 
4394 rajveer 10936 
class addAlert_args:
94 ashish 10937 
  """
10938 
  Attributes:
3064 chandransh 10939 
   - type
4444 rajveer 10940 
   - warehouseId
4394 rajveer 10941 
   - description
94 ashish 10942 
  """
10943 
 
10944 
  thrift_spec = (
10945 
    None, # 0
4394 rajveer 10946 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10947 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10948 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10949 
  )
10950 
 
4444 rajveer 10951 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10952 
    self.type = type
4444 rajveer 10953 
    self.warehouseId = warehouseId
4394 rajveer 10954 
    self.description = description
94 ashish 10955 
 
10956 
  def read(self, iprot):
10957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10959 
      return
10960 
    iprot.readStructBegin()
10961 
    while True:
10962 
      (fname, ftype, fid) = iprot.readFieldBegin()
10963 
      if ftype == TType.STOP:
10964 
        break
10965 
      if fid == 1:
10966 
        if ftype == TType.I64:
4394 rajveer 10967 
          self.type = iprot.readI64();
94 ashish 10968 
        else:
10969 
          iprot.skip(ftype)
3064 chandransh 10970 
      elif fid == 2:
4444 rajveer 10971 
        if ftype == TType.I64:
10972 
          self.warehouseId = iprot.readI64();
10973 
        else:
10974 
          iprot.skip(ftype)
10975 
      elif fid == 3:
3064 chandransh 10976 
        if ftype == TType.STRING:
4394 rajveer 10977 
          self.description = iprot.readString();
3064 chandransh 10978 
        else:
10979 
          iprot.skip(ftype)
94 ashish 10980 
      else:
10981 
        iprot.skip(ftype)
10982 
      iprot.readFieldEnd()
10983 
    iprot.readStructEnd()
10984 
 
10985 
  def write(self, oprot):
10986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10988 
      return
4394 rajveer 10989 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10990 
    if self.type is not None:
4394 rajveer 10991 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10992 
      oprot.writeI64(self.type)
10993 
      oprot.writeFieldEnd()
4444 rajveer 10994 
    if self.warehouseId is not None:
10995 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10996 
      oprot.writeI64(self.warehouseId)
10997 
      oprot.writeFieldEnd()
4394 rajveer 10998 
    if self.description is not None:
4444 rajveer 10999 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11000 
      oprot.writeString(self.description)
3064 chandransh 11001 
      oprot.writeFieldEnd()
94 ashish 11002 
    oprot.writeFieldStop()
11003 
    oprot.writeStructEnd()
11004 
 
3431 rajveer 11005 
  def validate(self):
11006 
    return
11007 
 
11008 
 
94 ashish 11009 
  def __repr__(self):
11010 
    L = ['%s=%r' % (key, value)
11011 
      for key, value in self.__dict__.iteritems()]
11012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11013 
 
11014 
  def __eq__(self, other):
11015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11016 
 
11017 
  def __ne__(self, other):
11018 
    return not (self == other)
11019 
 
4394 rajveer 11020 
class addAlert_result:
3064 chandransh 11021 
 
11022 
  thrift_spec = (
11023 
  )
11024 
 
11025 
  def read(self, iprot):
11026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11028 
      return
11029 
    iprot.readStructBegin()
11030 
    while True:
11031 
      (fname, ftype, fid) = iprot.readFieldBegin()
11032 
      if ftype == TType.STOP:
11033 
        break
11034 
      else:
11035 
        iprot.skip(ftype)
11036 
      iprot.readFieldEnd()
11037 
    iprot.readStructEnd()
11038 
 
11039 
  def write(self, oprot):
11040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11042 
      return
4394 rajveer 11043 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11044 
    oprot.writeFieldStop()
11045 
    oprot.writeStructEnd()
11046 
 
3431 rajveer 11047 
  def validate(self):
11048 
    return
11049 
 
11050 
 
3064 chandransh 11051 
  def __repr__(self):
11052 
    L = ['%s=%r' % (key, value)
11053 
      for key, value in self.__dict__.iteritems()]
11054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11055 
 
11056 
  def __eq__(self, other):
11057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11058 
 
11059 
  def __ne__(self, other):
11060 
    return not (self == other)
11061 
 
4444 rajveer 11062 
class markAlertsAsSeen_args:
11063 
  """
11064 
  Attributes:
11065 
   - warehouseId
11066 
  """
11067 
 
11068 
  thrift_spec = (
11069 
    None, # 0
11070 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11071 
  )
11072 
 
11073 
  def __init__(self, warehouseId=None,):
11074 
    self.warehouseId = warehouseId
11075 
 
11076 
  def read(self, iprot):
11077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11079 
      return
11080 
    iprot.readStructBegin()
11081 
    while True:
11082 
      (fname, ftype, fid) = iprot.readFieldBegin()
11083 
      if ftype == TType.STOP:
11084 
        break
11085 
      if fid == 1:
11086 
        if ftype == TType.I64:
11087 
          self.warehouseId = iprot.readI64();
11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      else:
11091 
        iprot.skip(ftype)
11092 
      iprot.readFieldEnd()
11093 
    iprot.readStructEnd()
11094 
 
11095 
  def write(self, oprot):
11096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11098 
      return
11099 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11100 
    if self.warehouseId is not None:
11101 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11102 
      oprot.writeI64(self.warehouseId)
11103 
      oprot.writeFieldEnd()
11104 
    oprot.writeFieldStop()
11105 
    oprot.writeStructEnd()
11106 
 
11107 
  def validate(self):
11108 
    return
11109 
 
11110 
 
11111 
  def __repr__(self):
11112 
    L = ['%s=%r' % (key, value)
11113 
      for key, value in self.__dict__.iteritems()]
11114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11115 
 
11116 
  def __eq__(self, other):
11117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11118 
 
11119 
  def __ne__(self, other):
11120 
    return not (self == other)
11121 
 
11122 
class markAlertsAsSeen_result:
11123 
 
11124 
  thrift_spec = (
11125 
  )
11126 
 
11127 
  def read(self, iprot):
11128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11130 
      return
11131 
    iprot.readStructBegin()
11132 
    while True:
11133 
      (fname, ftype, fid) = iprot.readFieldBegin()
11134 
      if ftype == TType.STOP:
11135 
        break
11136 
      else:
11137 
        iprot.skip(ftype)
11138 
      iprot.readFieldEnd()
11139 
    iprot.readStructEnd()
11140 
 
11141 
  def write(self, oprot):
11142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11144 
      return
11145 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11146 
    oprot.writeFieldStop()
11147 
    oprot.writeStructEnd()
11148 
 
11149 
  def validate(self):
11150 
    return
11151 
 
11152 
 
11153 
  def __repr__(self):
11154 
    L = ['%s=%r' % (key, value)
11155 
      for key, value in self.__dict__.iteritems()]
11156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11157 
 
11158 
  def __eq__(self, other):
11159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11160 
 
11161 
  def __ne__(self, other):
11162 
    return not (self == other)
11163 
 
3064 chandransh 11164 
class getValidOrderCount_args:
11165 
 
11166 
  thrift_spec = (
11167 
  )
11168 
 
11169 
  def read(self, iprot):
11170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11172 
      return
11173 
    iprot.readStructBegin()
11174 
    while True:
11175 
      (fname, ftype, fid) = iprot.readFieldBegin()
11176 
      if ftype == TType.STOP:
11177 
        break
11178 
      else:
11179 
        iprot.skip(ftype)
11180 
      iprot.readFieldEnd()
11181 
    iprot.readStructEnd()
11182 
 
11183 
  def write(self, oprot):
11184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11186 
      return
11187 
    oprot.writeStructBegin('getValidOrderCount_args')
11188 
    oprot.writeFieldStop()
11189 
    oprot.writeStructEnd()
11190 
 
3431 rajveer 11191 
  def validate(self):
11192 
    return
11193 
 
11194 
 
3064 chandransh 11195 
  def __repr__(self):
11196 
    L = ['%s=%r' % (key, value)
11197 
      for key, value in self.__dict__.iteritems()]
11198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11199 
 
11200 
  def __eq__(self, other):
11201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11202 
 
11203 
  def __ne__(self, other):
11204 
    return not (self == other)
11205 
 
11206 
class getValidOrderCount_result:
94 ashish 11207 
  """
11208 
  Attributes:
11209 
   - success
11210 
  """
11211 
 
11212 
  thrift_spec = (
3064 chandransh 11213 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11214 
  )
11215 
 
3064 chandransh 11216 
  def __init__(self, success=None,):
94 ashish 11217 
    self.success = success
11218 
 
11219 
  def read(self, iprot):
11220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11222 
      return
11223 
    iprot.readStructBegin()
11224 
    while True:
11225 
      (fname, ftype, fid) = iprot.readFieldBegin()
11226 
      if ftype == TType.STOP:
11227 
        break
11228 
      if fid == 0:
3064 chandransh 11229 
        if ftype == TType.I64:
11230 
          self.success = iprot.readI64();
94 ashish 11231 
        else:
11232 
          iprot.skip(ftype)
11233 
      else:
11234 
        iprot.skip(ftype)
11235 
      iprot.readFieldEnd()
11236 
    iprot.readStructEnd()
11237 
 
11238 
  def write(self, oprot):
11239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11241 
      return
3064 chandransh 11242 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11243 
    if self.success is not None:
3064 chandransh 11244 
      oprot.writeFieldBegin('success', TType.I64, 0)
11245 
      oprot.writeI64(self.success)
94 ashish 11246 
      oprot.writeFieldEnd()
11247 
    oprot.writeFieldStop()
11248 
    oprot.writeStructEnd()
11249 
 
3431 rajveer 11250 
  def validate(self):
11251 
    return
11252 
 
11253 
 
94 ashish 11254 
  def __repr__(self):
11255 
    L = ['%s=%r' % (key, value)
11256 
      for key, value in self.__dict__.iteritems()]
11257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11258 
 
11259 
  def __eq__(self, other):
11260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11261 
 
11262 
  def __ne__(self, other):
11263 
    return not (self == other)
11264 
 
3064 chandransh 11265 
class getNoOfCustomersWithSuccessfulTransaction_args:
11266 
 
11267 
  thrift_spec = (
11268 
  )
11269 
 
11270 
  def read(self, iprot):
11271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11273 
      return
11274 
    iprot.readStructBegin()
11275 
    while True:
11276 
      (fname, ftype, fid) = iprot.readFieldBegin()
11277 
      if ftype == TType.STOP:
11278 
        break
11279 
      else:
11280 
        iprot.skip(ftype)
11281 
      iprot.readFieldEnd()
11282 
    iprot.readStructEnd()
11283 
 
11284 
  def write(self, oprot):
11285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11287 
      return
11288 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11289 
    oprot.writeFieldStop()
11290 
    oprot.writeStructEnd()
11291 
 
3431 rajveer 11292 
  def validate(self):
11293 
    return
11294 
 
11295 
 
3064 chandransh 11296 
  def __repr__(self):
11297 
    L = ['%s=%r' % (key, value)
11298 
      for key, value in self.__dict__.iteritems()]
11299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11300 
 
11301 
  def __eq__(self, other):
11302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11303 
 
11304 
  def __ne__(self, other):
11305 
    return not (self == other)
11306 
 
11307 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11308 
  """
11309 
  Attributes:
3064 chandransh 11310 
   - success
94 ashish 11311 
  """
11312 
 
11313 
  thrift_spec = (
3064 chandransh 11314 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11315 
  )
11316 
 
3064 chandransh 11317 
  def __init__(self, success=None,):
11318 
    self.success = success
94 ashish 11319 
 
11320 
  def read(self, iprot):
11321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11323 
      return
11324 
    iprot.readStructBegin()
11325 
    while True:
11326 
      (fname, ftype, fid) = iprot.readFieldBegin()
11327 
      if ftype == TType.STOP:
11328 
        break
3064 chandransh 11329 
      if fid == 0:
94 ashish 11330 
        if ftype == TType.I64:
3064 chandransh 11331 
          self.success = iprot.readI64();
94 ashish 11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      else:
11335 
        iprot.skip(ftype)
11336 
      iprot.readFieldEnd()
11337 
    iprot.readStructEnd()
11338 
 
11339 
  def write(self, oprot):
11340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11342 
      return
3064 chandransh 11343 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11344 
    if self.success is not None:
3064 chandransh 11345 
      oprot.writeFieldBegin('success', TType.I64, 0)
11346 
      oprot.writeI64(self.success)
94 ashish 11347 
      oprot.writeFieldEnd()
11348 
    oprot.writeFieldStop()
11349 
    oprot.writeStructEnd()
11350 
 
3431 rajveer 11351 
  def validate(self):
11352 
    return
11353 
 
11354 
 
94 ashish 11355 
  def __repr__(self):
11356 
    L = ['%s=%r' % (key, value)
11357 
      for key, value in self.__dict__.iteritems()]
11358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11359 
 
11360 
  def __eq__(self, other):
11361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11362 
 
11363 
  def __ne__(self, other):
11364 
    return not (self == other)
11365 
 
3064 chandransh 11366 
class getValidOrdersAmountRange_args:
11367 
 
11368 
  thrift_spec = (
11369 
  )
11370 
 
11371 
  def read(self, iprot):
11372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11374 
      return
11375 
    iprot.readStructBegin()
11376 
    while True:
11377 
      (fname, ftype, fid) = iprot.readFieldBegin()
11378 
      if ftype == TType.STOP:
11379 
        break
11380 
      else:
11381 
        iprot.skip(ftype)
11382 
      iprot.readFieldEnd()
11383 
    iprot.readStructEnd()
11384 
 
11385 
  def write(self, oprot):
11386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11388 
      return
11389 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11390 
    oprot.writeFieldStop()
11391 
    oprot.writeStructEnd()
11392 
 
3431 rajveer 11393 
  def validate(self):
11394 
    return
11395 
 
11396 
 
3064 chandransh 11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
11408 
class getValidOrdersAmountRange_result:
94 ashish 11409 
  """
11410 
  Attributes:
11411 
   - success
11412 
  """
11413 
 
11414 
  thrift_spec = (
3064 chandransh 11415 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11416 
  )
11417 
 
3064 chandransh 11418 
  def __init__(self, success=None,):
94 ashish 11419 
    self.success = success
11420 
 
11421 
  def read(self, iprot):
11422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11424 
      return
11425 
    iprot.readStructBegin()
11426 
    while True:
11427 
      (fname, ftype, fid) = iprot.readFieldBegin()
11428 
      if ftype == TType.STOP:
11429 
        break
11430 
      if fid == 0:
483 rajveer 11431 
        if ftype == TType.LIST:
11432 
          self.success = []
5386 phani.kuma 11433 
          (_etype206, _size203) = iprot.readListBegin()
11434 
          for _i207 in xrange(_size203):
11435 
            _elem208 = iprot.readDouble();
11436 
            self.success.append(_elem208)
483 rajveer 11437 
          iprot.readListEnd()
94 ashish 11438 
        else:
11439 
          iprot.skip(ftype)
11440 
      else:
11441 
        iprot.skip(ftype)
11442 
      iprot.readFieldEnd()
11443 
    iprot.readStructEnd()
11444 
 
11445 
  def write(self, oprot):
11446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11448 
      return
3064 chandransh 11449 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11450 
    if self.success is not None:
483 rajveer 11451 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11452 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11453 
      for iter209 in self.success:
11454 
        oprot.writeDouble(iter209)
483 rajveer 11455 
      oprot.writeListEnd()
94 ashish 11456 
      oprot.writeFieldEnd()
11457 
    oprot.writeFieldStop()
11458 
    oprot.writeStructEnd()
11459 
 
3431 rajveer 11460 
  def validate(self):
11461 
    return
11462 
 
11463 
 
94 ashish 11464 
  def __repr__(self):
11465 
    L = ['%s=%r' % (key, value)
11466 
      for key, value in self.__dict__.iteritems()]
11467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11468 
 
11469 
  def __eq__(self, other):
11470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11471 
 
11472 
  def __ne__(self, other):
11473 
    return not (self == other)
11474 
 
3064 chandransh 11475 
class getValidOrders_args:
1528 ankur.sing 11476 
  """
11477 
  Attributes:
3064 chandransh 11478 
   - limit
1528 ankur.sing 11479 
  """
11480 
 
11481 
  thrift_spec = (
11482 
    None, # 0
3064 chandransh 11483 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11484 
  )
11485 
 
3064 chandransh 11486 
  def __init__(self, limit=None,):
11487 
    self.limit = limit
1528 ankur.sing 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 == 1:
11499 
        if ftype == TType.I64:
3064 chandransh 11500 
          self.limit = iprot.readI64();
1528 ankur.sing 11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      else:
11504 
        iprot.skip(ftype)
11505 
      iprot.readFieldEnd()
11506 
    iprot.readStructEnd()
11507 
 
11508 
  def write(self, oprot):
11509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11511 
      return
3064 chandransh 11512 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11513 
    if self.limit is not None:
3064 chandransh 11514 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11515 
      oprot.writeI64(self.limit)
1528 ankur.sing 11516 
      oprot.writeFieldEnd()
11517 
    oprot.writeFieldStop()
11518 
    oprot.writeStructEnd()
11519 
 
3431 rajveer 11520 
  def validate(self):
11521 
    return
11522 
 
11523 
 
1528 ankur.sing 11524 
  def __repr__(self):
11525 
    L = ['%s=%r' % (key, value)
11526 
      for key, value in self.__dict__.iteritems()]
11527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11528 
 
11529 
  def __eq__(self, other):
11530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11531 
 
11532 
  def __ne__(self, other):
11533 
    return not (self == other)
11534 
 
3064 chandransh 11535 
class getValidOrders_result:
1528 ankur.sing 11536 
  """
11537 
  Attributes:
11538 
   - success
11539 
  """
11540 
 
11541 
  thrift_spec = (
3064 chandransh 11542 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11543 
  )
11544 
 
3064 chandransh 11545 
  def __init__(self, success=None,):
1528 ankur.sing 11546 
    self.success = success
11547 
 
11548 
  def read(self, iprot):
11549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11551 
      return
11552 
    iprot.readStructBegin()
11553 
    while True:
11554 
      (fname, ftype, fid) = iprot.readFieldBegin()
11555 
      if ftype == TType.STOP:
11556 
        break
11557 
      if fid == 0:
3064 chandransh 11558 
        if ftype == TType.LIST:
11559 
          self.success = []
5386 phani.kuma 11560 
          (_etype213, _size210) = iprot.readListBegin()
11561 
          for _i214 in xrange(_size210):
11562 
            _elem215 = Order()
11563 
            _elem215.read(iprot)
11564 
            self.success.append(_elem215)
3064 chandransh 11565 
          iprot.readListEnd()
1528 ankur.sing 11566 
        else:
11567 
          iprot.skip(ftype)
11568 
      else:
11569 
        iprot.skip(ftype)
11570 
      iprot.readFieldEnd()
11571 
    iprot.readStructEnd()
11572 
 
11573 
  def write(self, oprot):
11574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11576 
      return
3064 chandransh 11577 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11578 
    if self.success is not None:
3064 chandransh 11579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11581 
      for iter216 in self.success:
11582 
        iter216.write(oprot)
3064 chandransh 11583 
      oprot.writeListEnd()
1528 ankur.sing 11584 
      oprot.writeFieldEnd()
11585 
    oprot.writeFieldStop()
11586 
    oprot.writeStructEnd()
11587 
 
3431 rajveer 11588 
  def validate(self):
11589 
    return
11590 
 
11591 
 
1528 ankur.sing 11592 
  def __repr__(self):
11593 
    L = ['%s=%r' % (key, value)
11594 
      for key, value in self.__dict__.iteritems()]
11595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11596 
 
11597 
  def __eq__(self, other):
11598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11599 
 
11600 
  def __ne__(self, other):
11601 
    return not (self == other)
11602 
 
1220 chandransh 11603 
class batchOrders_args:
11604 
  """
11605 
  Attributes:
11606 
   - warehouseId
11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    None, # 0
11611 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11612 
  )
11613 
 
11614 
  def __init__(self, warehouseId=None,):
11615 
    self.warehouseId = warehouseId
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 1:
11627 
        if ftype == TType.I64:
11628 
          self.warehouseId = iprot.readI64();
11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      else:
11632 
        iprot.skip(ftype)
11633 
      iprot.readFieldEnd()
11634 
    iprot.readStructEnd()
11635 
 
11636 
  def write(self, oprot):
11637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11639 
      return
11640 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11641 
    if self.warehouseId is not None:
1220 chandransh 11642 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11643 
      oprot.writeI64(self.warehouseId)
11644 
      oprot.writeFieldEnd()
11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
3431 rajveer 11648 
  def validate(self):
11649 
    return
11650 
 
11651 
 
1220 chandransh 11652 
  def __repr__(self):
11653 
    L = ['%s=%r' % (key, value)
11654 
      for key, value in self.__dict__.iteritems()]
11655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11656 
 
11657 
  def __eq__(self, other):
11658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11659 
 
11660 
  def __ne__(self, other):
11661 
    return not (self == other)
11662 
 
11663 
class batchOrders_result:
11664 
  """
11665 
  Attributes:
11666 
   - success
11667 
   - ex
11668 
  """
11669 
 
11670 
  thrift_spec = (
11671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11673 
  )
11674 
 
11675 
  def __init__(self, success=None, ex=None,):
11676 
    self.success = success
11677 
    self.ex = ex
11678 
 
11679 
  def read(self, iprot):
11680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11682 
      return
11683 
    iprot.readStructBegin()
11684 
    while True:
11685 
      (fname, ftype, fid) = iprot.readFieldBegin()
11686 
      if ftype == TType.STOP:
11687 
        break
11688 
      if fid == 0:
11689 
        if ftype == TType.LIST:
11690 
          self.success = []
5386 phani.kuma 11691 
          (_etype220, _size217) = iprot.readListBegin()
11692 
          for _i221 in xrange(_size217):
11693 
            _elem222 = Order()
11694 
            _elem222.read(iprot)
11695 
            self.success.append(_elem222)
1220 chandransh 11696 
          iprot.readListEnd()
11697 
        else:
11698 
          iprot.skip(ftype)
11699 
      elif fid == 1:
11700 
        if ftype == TType.STRUCT:
11701 
          self.ex = TransactionServiceException()
11702 
          self.ex.read(iprot)
11703 
        else:
11704 
          iprot.skip(ftype)
11705 
      else:
11706 
        iprot.skip(ftype)
11707 
      iprot.readFieldEnd()
11708 
    iprot.readStructEnd()
11709 
 
11710 
  def write(self, oprot):
11711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11713 
      return
11714 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11715 
    if self.success is not None:
1220 chandransh 11716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11718 
      for iter223 in self.success:
11719 
        iter223.write(oprot)
1220 chandransh 11720 
      oprot.writeListEnd()
11721 
      oprot.writeFieldEnd()
3431 rajveer 11722 
    if self.ex is not None:
1220 chandransh 11723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11724 
      self.ex.write(oprot)
11725 
      oprot.writeFieldEnd()
11726 
    oprot.writeFieldStop()
11727 
    oprot.writeStructEnd()
11728 
 
3431 rajveer 11729 
  def validate(self):
11730 
    return
11731 
 
11732 
 
1220 chandransh 11733 
  def __repr__(self):
11734 
    L = ['%s=%r' % (key, value)
11735 
      for key, value in self.__dict__.iteritems()]
11736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11737 
 
11738 
  def __eq__(self, other):
11739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11740 
 
11741 
  def __ne__(self, other):
11742 
    return not (self == other)
11743 
 
1208 chandransh 11744 
class markOrderAsOutOfStock_args:
11745 
  """
11746 
  Attributes:
11747 
   - orderId
11748 
  """
11749 
 
11750 
  thrift_spec = (
11751 
    None, # 0
11752 
    (1, TType.I64, 'orderId', None, None, ), # 1
11753 
  )
11754 
 
11755 
  def __init__(self, orderId=None,):
11756 
    self.orderId = orderId
11757 
 
11758 
  def read(self, iprot):
11759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11761 
      return
11762 
    iprot.readStructBegin()
11763 
    while True:
11764 
      (fname, ftype, fid) = iprot.readFieldBegin()
11765 
      if ftype == TType.STOP:
11766 
        break
11767 
      if fid == 1:
11768 
        if ftype == TType.I64:
11769 
          self.orderId = iprot.readI64();
11770 
        else:
11771 
          iprot.skip(ftype)
11772 
      else:
11773 
        iprot.skip(ftype)
11774 
      iprot.readFieldEnd()
11775 
    iprot.readStructEnd()
11776 
 
11777 
  def write(self, oprot):
11778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11780 
      return
11781 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11782 
    if self.orderId is not None:
1208 chandransh 11783 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11784 
      oprot.writeI64(self.orderId)
11785 
      oprot.writeFieldEnd()
11786 
    oprot.writeFieldStop()
11787 
    oprot.writeStructEnd()
11788 
 
3431 rajveer 11789 
  def validate(self):
11790 
    return
11791 
 
11792 
 
1208 chandransh 11793 
  def __repr__(self):
11794 
    L = ['%s=%r' % (key, value)
11795 
      for key, value in self.__dict__.iteritems()]
11796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11797 
 
11798 
  def __eq__(self, other):
11799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11800 
 
11801 
  def __ne__(self, other):
11802 
    return not (self == other)
11803 
 
11804 
class markOrderAsOutOfStock_result:
11805 
  """
11806 
  Attributes:
11807 
   - success
11808 
   - ex
11809 
  """
11810 
 
11811 
  thrift_spec = (
11812 
    (0, TType.BOOL, 'success', None, None, ), # 0
11813 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11814 
  )
11815 
 
11816 
  def __init__(self, success=None, ex=None,):
11817 
    self.success = success
11818 
    self.ex = ex
11819 
 
11820 
  def read(self, iprot):
11821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11823 
      return
11824 
    iprot.readStructBegin()
11825 
    while True:
11826 
      (fname, ftype, fid) = iprot.readFieldBegin()
11827 
      if ftype == TType.STOP:
11828 
        break
11829 
      if fid == 0:
11830 
        if ftype == TType.BOOL:
11831 
          self.success = iprot.readBool();
11832 
        else:
11833 
          iprot.skip(ftype)
11834 
      elif fid == 1:
11835 
        if ftype == TType.STRUCT:
11836 
          self.ex = TransactionServiceException()
11837 
          self.ex.read(iprot)
11838 
        else:
11839 
          iprot.skip(ftype)
11840 
      else:
11841 
        iprot.skip(ftype)
11842 
      iprot.readFieldEnd()
11843 
    iprot.readStructEnd()
11844 
 
11845 
  def write(self, oprot):
11846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11848 
      return
11849 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11850 
    if self.success is not None:
1208 chandransh 11851 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11852 
      oprot.writeBool(self.success)
11853 
      oprot.writeFieldEnd()
3431 rajveer 11854 
    if self.ex is not None:
1208 chandransh 11855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11856 
      self.ex.write(oprot)
11857 
      oprot.writeFieldEnd()
11858 
    oprot.writeFieldStop()
11859 
    oprot.writeStructEnd()
11860 
 
3431 rajveer 11861 
  def validate(self):
11862 
    return
11863 
 
11864 
 
1208 chandransh 11865 
  def __repr__(self):
11866 
    L = ['%s=%r' % (key, value)
11867 
      for key, value in self.__dict__.iteritems()]
11868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11869 
 
11870 
  def __eq__(self, other):
11871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11872 
 
11873 
  def __ne__(self, other):
11874 
    return not (self == other)
11875 
 
3064 chandransh 11876 
class verifyOrder_args:
759 chandransh 11877 
  """
11878 
  Attributes:
3064 chandransh 11879 
   - orderId
759 chandransh 11880 
  """
11881 
 
11882 
  thrift_spec = (
11883 
    None, # 0
3064 chandransh 11884 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11885 
  )
11886 
 
3064 chandransh 11887 
  def __init__(self, orderId=None,):
11888 
    self.orderId = orderId
759 chandransh 11889 
 
11890 
  def read(self, iprot):
11891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11893 
      return
11894 
    iprot.readStructBegin()
11895 
    while True:
11896 
      (fname, ftype, fid) = iprot.readFieldBegin()
11897 
      if ftype == TType.STOP:
11898 
        break
11899 
      if fid == 1:
11900 
        if ftype == TType.I64:
3064 chandransh 11901 
          self.orderId = iprot.readI64();
759 chandransh 11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      else:
11905 
        iprot.skip(ftype)
11906 
      iprot.readFieldEnd()
11907 
    iprot.readStructEnd()
11908 
 
11909 
  def write(self, oprot):
11910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11912 
      return
3064 chandransh 11913 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11914 
    if self.orderId is not None:
3064 chandransh 11915 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11916 
      oprot.writeI64(self.orderId)
759 chandransh 11917 
      oprot.writeFieldEnd()
11918 
    oprot.writeFieldStop()
11919 
    oprot.writeStructEnd()
11920 
 
3431 rajveer 11921 
  def validate(self):
11922 
    return
11923 
 
11924 
 
759 chandransh 11925 
  def __repr__(self):
11926 
    L = ['%s=%r' % (key, value)
11927 
      for key, value in self.__dict__.iteritems()]
11928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11929 
 
11930 
  def __eq__(self, other):
11931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11932 
 
11933 
  def __ne__(self, other):
11934 
    return not (self == other)
11935 
 
3064 chandransh 11936 
class verifyOrder_result:
759 chandransh 11937 
  """
11938 
  Attributes:
11939 
   - success
11940 
   - ex
11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    (0, TType.BOOL, 'success', None, None, ), # 0
11945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11946 
  )
11947 
 
11948 
  def __init__(self, success=None, ex=None,):
11949 
    self.success = success
11950 
    self.ex = ex
11951 
 
11952 
  def read(self, iprot):
11953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11955 
      return
11956 
    iprot.readStructBegin()
11957 
    while True:
11958 
      (fname, ftype, fid) = iprot.readFieldBegin()
11959 
      if ftype == TType.STOP:
11960 
        break
11961 
      if fid == 0:
11962 
        if ftype == TType.BOOL:
11963 
          self.success = iprot.readBool();
11964 
        else:
11965 
          iprot.skip(ftype)
11966 
      elif fid == 1:
11967 
        if ftype == TType.STRUCT:
11968 
          self.ex = TransactionServiceException()
11969 
          self.ex.read(iprot)
11970 
        else:
11971 
          iprot.skip(ftype)
11972 
      else:
11973 
        iprot.skip(ftype)
11974 
      iprot.readFieldEnd()
11975 
    iprot.readStructEnd()
11976 
 
11977 
  def write(self, oprot):
11978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11980 
      return
3064 chandransh 11981 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11982 
    if self.success is not None:
759 chandransh 11983 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11984 
      oprot.writeBool(self.success)
11985 
      oprot.writeFieldEnd()
3431 rajveer 11986 
    if self.ex is not None:
759 chandransh 11987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11988 
      self.ex.write(oprot)
11989 
      oprot.writeFieldEnd()
11990 
    oprot.writeFieldStop()
11991 
    oprot.writeStructEnd()
11992 
 
3431 rajveer 11993 
  def validate(self):
11994 
    return
11995 
 
11996 
 
759 chandransh 11997 
  def __repr__(self):
11998 
    L = ['%s=%r' % (key, value)
11999 
      for key, value in self.__dict__.iteritems()]
12000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12001 
 
12002 
  def __eq__(self, other):
12003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12004 
 
12005 
  def __ne__(self, other):
12006 
    return not (self == other)
12007 
 
3064 chandransh 12008 
class acceptOrder_args:
1113 chandransh 12009 
  """
12010 
  Attributes:
3064 chandransh 12011 
   - orderId
1113 chandransh 12012 
  """
12013 
 
12014 
  thrift_spec = (
12015 
    None, # 0
3064 chandransh 12016 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12017 
  )
12018 
 
3064 chandransh 12019 
  def __init__(self, orderId=None,):
12020 
    self.orderId = orderId
1113 chandransh 12021 
 
12022 
  def read(self, iprot):
12023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12025 
      return
12026 
    iprot.readStructBegin()
12027 
    while True:
12028 
      (fname, ftype, fid) = iprot.readFieldBegin()
12029 
      if ftype == TType.STOP:
12030 
        break
12031 
      if fid == 1:
12032 
        if ftype == TType.I64:
3064 chandransh 12033 
          self.orderId = iprot.readI64();
1113 chandransh 12034 
        else:
12035 
          iprot.skip(ftype)
12036 
      else:
12037 
        iprot.skip(ftype)
12038 
      iprot.readFieldEnd()
12039 
    iprot.readStructEnd()
12040 
 
12041 
  def write(self, oprot):
12042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12044 
      return
3064 chandransh 12045 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12046 
    if self.orderId is not None:
3064 chandransh 12047 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12048 
      oprot.writeI64(self.orderId)
1113 chandransh 12049 
      oprot.writeFieldEnd()
12050 
    oprot.writeFieldStop()
12051 
    oprot.writeStructEnd()
12052 
 
3431 rajveer 12053 
  def validate(self):
12054 
    return
12055 
 
12056 
 
1113 chandransh 12057 
  def __repr__(self):
12058 
    L = ['%s=%r' % (key, value)
12059 
      for key, value in self.__dict__.iteritems()]
12060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12061 
 
12062 
  def __eq__(self, other):
12063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12064 
 
12065 
  def __ne__(self, other):
12066 
    return not (self == other)
12067 
 
3064 chandransh 12068 
class acceptOrder_result:
1113 chandransh 12069 
  """
12070 
  Attributes:
12071 
   - success
12072 
   - ex
12073 
  """
12074 
 
12075 
  thrift_spec = (
3064 chandransh 12076 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12078 
  )
12079 
 
12080 
  def __init__(self, success=None, ex=None,):
12081 
    self.success = success
12082 
    self.ex = ex
12083 
 
12084 
  def read(self, iprot):
12085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12087 
      return
12088 
    iprot.readStructBegin()
12089 
    while True:
12090 
      (fname, ftype, fid) = iprot.readFieldBegin()
12091 
      if ftype == TType.STOP:
12092 
        break
12093 
      if fid == 0:
3064 chandransh 12094 
        if ftype == TType.BOOL:
12095 
          self.success = iprot.readBool();
1113 chandransh 12096 
        else:
12097 
          iprot.skip(ftype)
12098 
      elif fid == 1:
12099 
        if ftype == TType.STRUCT:
12100 
          self.ex = TransactionServiceException()
12101 
          self.ex.read(iprot)
12102 
        else:
12103 
          iprot.skip(ftype)
12104 
      else:
12105 
        iprot.skip(ftype)
12106 
      iprot.readFieldEnd()
12107 
    iprot.readStructEnd()
12108 
 
12109 
  def write(self, oprot):
12110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12112 
      return
3064 chandransh 12113 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12114 
    if self.success is not None:
3064 chandransh 12115 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12116 
      oprot.writeBool(self.success)
1113 chandransh 12117 
      oprot.writeFieldEnd()
3431 rajveer 12118 
    if self.ex is not None:
1113 chandransh 12119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12120 
      self.ex.write(oprot)
12121 
      oprot.writeFieldEnd()
12122 
    oprot.writeFieldStop()
12123 
    oprot.writeStructEnd()
12124 
 
3431 rajveer 12125 
  def validate(self):
12126 
    return
12127 
 
12128 
 
1113 chandransh 12129 
  def __repr__(self):
12130 
    L = ['%s=%r' % (key, value)
12131 
      for key, value in self.__dict__.iteritems()]
12132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12133 
 
12134 
  def __eq__(self, other):
12135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12136 
 
12137 
  def __ne__(self, other):
12138 
    return not (self == other)
12139 
 
3064 chandransh 12140 
class addBillingDetails_args:
1135 chandransh 12141 
  """
12142 
  Attributes:
3064 chandransh 12143 
   - orderId
12144 
   - invoice_number
4658 mandeep.dh 12145 
   - serialNumber
4283 anupam.sin 12146 
   - itemNumber
3064 chandransh 12147 
   - billed_by
4264 rajveer 12148 
   - jacketNumber
4283 anupam.sin 12149 
   - billingType
5110 mandeep.dh 12150 
   - fulfilmentWarehouseId
4763 rajveer 12151 
   - authorize
1135 chandransh 12152 
  """
12153 
 
12154 
  thrift_spec = (
12155 
    None, # 0
3064 chandransh 12156 
    (1, TType.I64, 'orderId', None, None, ), # 1
12157 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12158 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12159 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12160 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12161 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12162 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12163 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12164 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12165 
  )
12166 
 
5110 mandeep.dh 12167 
  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 12168 
    self.orderId = orderId
12169 
    self.invoice_number = invoice_number
4658 mandeep.dh 12170 
    self.serialNumber = serialNumber
4283 anupam.sin 12171 
    self.itemNumber = itemNumber
3064 chandransh 12172 
    self.billed_by = billed_by
4264 rajveer 12173 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12174 
    self.billingType = billingType
5110 mandeep.dh 12175 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12176 
    self.authorize = authorize
1135 chandransh 12177 
 
12178 
  def read(self, iprot):
12179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12181 
      return
12182 
    iprot.readStructBegin()
12183 
    while True:
12184 
      (fname, ftype, fid) = iprot.readFieldBegin()
12185 
      if ftype == TType.STOP:
12186 
        break
12187 
      if fid == 1:
12188 
        if ftype == TType.I64:
3064 chandransh 12189 
          self.orderId = iprot.readI64();
1135 chandransh 12190 
        else:
12191 
          iprot.skip(ftype)
12192 
      elif fid == 2:
3064 chandransh 12193 
        if ftype == TType.STRING:
12194 
          self.invoice_number = iprot.readString();
1135 chandransh 12195 
        else:
12196 
          iprot.skip(ftype)
3064 chandransh 12197 
      elif fid == 3:
5411 rajveer 12198 
        if ftype == TType.LIST:
12199 
          self.serialNumber = []
12200 
          (_etype227, _size224) = iprot.readListBegin()
12201 
          for _i228 in xrange(_size224):
12202 
            _elem229 = iprot.readString();
12203 
            self.serialNumber.append(_elem229)
12204 
          iprot.readListEnd()
3064 chandransh 12205 
        else:
12206 
          iprot.skip(ftype)
12207 
      elif fid == 4:
5411 rajveer 12208 
        if ftype == TType.LIST:
12209 
          self.itemNumber = []
12210 
          (_etype233, _size230) = iprot.readListBegin()
12211 
          for _i234 in xrange(_size230):
12212 
            _elem235 = iprot.readString();
12213 
            self.itemNumber.append(_elem235)
12214 
          iprot.readListEnd()
3064 chandransh 12215 
        else:
12216 
          iprot.skip(ftype)
12217 
      elif fid == 5:
12218 
        if ftype == TType.STRING:
4283 anupam.sin 12219 
          self.billed_by = iprot.readString();
3064 chandransh 12220 
        else:
12221 
          iprot.skip(ftype)
12222 
      elif fid == 6:
12223 
        if ftype == TType.I64:
4283 anupam.sin 12224 
          self.jacketNumber = iprot.readI64();
12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      elif fid == 7:
12228 
        if ftype == TType.I64:
3064 chandransh 12229 
          self.billingType = iprot.readI64();
12230 
        else:
12231 
          iprot.skip(ftype)
4283 anupam.sin 12232 
      elif fid == 8:
12233 
        if ftype == TType.I64:
5110 mandeep.dh 12234 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12235 
        else:
12236 
          iprot.skip(ftype)
4763 rajveer 12237 
      elif fid == 9:
12238 
        if ftype == TType.BOOL:
12239 
          self.authorize = iprot.readBool();
12240 
        else:
12241 
          iprot.skip(ftype)
1246 chandransh 12242 
      else:
12243 
        iprot.skip(ftype)
12244 
      iprot.readFieldEnd()
12245 
    iprot.readStructEnd()
12246 
 
12247 
  def write(self, oprot):
12248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12250 
      return
4283 anupam.sin 12251 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12252 
    if self.orderId is not None:
3064 chandransh 12253 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12254 
      oprot.writeI64(self.orderId)
1246 chandransh 12255 
      oprot.writeFieldEnd()
4283 anupam.sin 12256 
    if self.invoice_number is not None:
12257 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12258 
      oprot.writeString(self.invoice_number)
1246 chandransh 12259 
      oprot.writeFieldEnd()
4658 mandeep.dh 12260 
    if self.serialNumber is not None:
5411 rajveer 12261 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12262 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12263 
      for iter236 in self.serialNumber:
12264 
        oprot.writeString(iter236)
12265 
      oprot.writeListEnd()
3064 chandransh 12266 
      oprot.writeFieldEnd()
3431 rajveer 12267 
    if self.itemNumber is not None:
5411 rajveer 12268 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12269 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12270 
      for iter237 in self.itemNumber:
12271 
        oprot.writeString(iter237)
12272 
      oprot.writeListEnd()
3064 chandransh 12273 
      oprot.writeFieldEnd()
4283 anupam.sin 12274 
    if self.billed_by is not None:
12275 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12276 
      oprot.writeString(self.billed_by)
3064 chandransh 12277 
      oprot.writeFieldEnd()
4283 anupam.sin 12278 
    if self.jacketNumber is not None:
12279 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12280 
      oprot.writeI64(self.jacketNumber)
12281 
      oprot.writeFieldEnd()
3431 rajveer 12282 
    if self.billingType is not None:
4283 anupam.sin 12283 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12284 
      oprot.writeI64(self.billingType)
12285 
      oprot.writeFieldEnd()
5110 mandeep.dh 12286 
    if self.fulfilmentWarehouseId is not None:
12287 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12288 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12289 
      oprot.writeFieldEnd()
4763 rajveer 12290 
    if self.authorize is not None:
12291 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12292 
      oprot.writeBool(self.authorize)
12293 
      oprot.writeFieldEnd()
1246 chandransh 12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
3431 rajveer 12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
1246 chandransh 12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
4283 anupam.sin 12312 
class addBillingDetails_result:
1246 chandransh 12313 
  """
12314 
  Attributes:
3064 chandransh 12315 
   - success
1246 chandransh 12316 
   - ex
12317 
  """
12318 
 
12319 
  thrift_spec = (
3064 chandransh 12320 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12321 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12322 
  )
12323 
 
3064 chandransh 12324 
  def __init__(self, success=None, ex=None,):
12325 
    self.success = success
1246 chandransh 12326 
    self.ex = ex
12327 
 
12328 
  def read(self, iprot):
12329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12331 
      return
12332 
    iprot.readStructBegin()
12333 
    while True:
12334 
      (fname, ftype, fid) = iprot.readFieldBegin()
12335 
      if ftype == TType.STOP:
12336 
        break
3064 chandransh 12337 
      if fid == 0:
12338 
        if ftype == TType.BOOL:
12339 
          self.success = iprot.readBool();
12340 
        else:
12341 
          iprot.skip(ftype)
12342 
      elif fid == 1:
1246 chandransh 12343 
        if ftype == TType.STRUCT:
12344 
          self.ex = TransactionServiceException()
12345 
          self.ex.read(iprot)
12346 
        else:
12347 
          iprot.skip(ftype)
12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
4283 anupam.sin 12357 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12358 
    if self.success is not None:
3064 chandransh 12359 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12360 
      oprot.writeBool(self.success)
12361 
      oprot.writeFieldEnd()
3431 rajveer 12362 
    if self.ex is not None:
1246 chandransh 12363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12364 
      self.ex.write(oprot)
12365 
      oprot.writeFieldEnd()
12366 
    oprot.writeFieldStop()
12367 
    oprot.writeStructEnd()
12368 
 
3431 rajveer 12369 
  def validate(self):
12370 
    return
12371 
 
12372 
 
1246 chandransh 12373 
  def __repr__(self):
12374 
    L = ['%s=%r' % (key, value)
12375 
      for key, value in self.__dict__.iteritems()]
12376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12377 
 
12378 
  def __eq__(self, other):
12379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12380 
 
12381 
  def __ne__(self, other):
12382 
    return not (self == other)
12383 
 
4579 rajveer 12384 
class addInvoiceNumber_args:
12385 
  """
12386 
  Attributes:
12387 
   - orderId
12388 
   - invoiceNumber
4763 rajveer 12389 
   - color
4579 rajveer 12390 
  """
12391 
 
12392 
  thrift_spec = (
12393 
    None, # 0
12394 
    (1, TType.I64, 'orderId', None, None, ), # 1
12395 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12396 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12397 
  )
12398 
 
4763 rajveer 12399 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12400 
    self.orderId = orderId
12401 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12402 
    self.color = color
4579 rajveer 12403 
 
12404 
  def read(self, iprot):
12405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12407 
      return
12408 
    iprot.readStructBegin()
12409 
    while True:
12410 
      (fname, ftype, fid) = iprot.readFieldBegin()
12411 
      if ftype == TType.STOP:
12412 
        break
12413 
      if fid == 1:
12414 
        if ftype == TType.I64:
12415 
          self.orderId = iprot.readI64();
12416 
        else:
12417 
          iprot.skip(ftype)
12418 
      elif fid == 2:
12419 
        if ftype == TType.STRING:
12420 
          self.invoiceNumber = iprot.readString();
12421 
        else:
12422 
          iprot.skip(ftype)
4763 rajveer 12423 
      elif fid == 3:
12424 
        if ftype == TType.STRING:
12425 
          self.color = iprot.readString();
12426 
        else:
12427 
          iprot.skip(ftype)
4579 rajveer 12428 
      else:
12429 
        iprot.skip(ftype)
12430 
      iprot.readFieldEnd()
12431 
    iprot.readStructEnd()
12432 
 
12433 
  def write(self, oprot):
12434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12436 
      return
12437 
    oprot.writeStructBegin('addInvoiceNumber_args')
12438 
    if self.orderId is not None:
12439 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12440 
      oprot.writeI64(self.orderId)
12441 
      oprot.writeFieldEnd()
12442 
    if self.invoiceNumber is not None:
12443 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12444 
      oprot.writeString(self.invoiceNumber)
12445 
      oprot.writeFieldEnd()
4763 rajveer 12446 
    if self.color is not None:
12447 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12448 
      oprot.writeString(self.color)
12449 
      oprot.writeFieldEnd()
4579 rajveer 12450 
    oprot.writeFieldStop()
12451 
    oprot.writeStructEnd()
12452 
 
12453 
  def validate(self):
12454 
    return
12455 
 
12456 
 
12457 
  def __repr__(self):
12458 
    L = ['%s=%r' % (key, value)
12459 
      for key, value in self.__dict__.iteritems()]
12460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12461 
 
12462 
  def __eq__(self, other):
12463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12464 
 
12465 
  def __ne__(self, other):
12466 
    return not (self == other)
12467 
 
12468 
class addInvoiceNumber_result:
12469 
  """
12470 
  Attributes:
12471 
   - ex
12472 
  """
12473 
 
12474 
  thrift_spec = (
12475 
    None, # 0
12476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12477 
  )
12478 
 
12479 
  def __init__(self, ex=None,):
12480 
    self.ex = ex
12481 
 
12482 
  def read(self, iprot):
12483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12485 
      return
12486 
    iprot.readStructBegin()
12487 
    while True:
12488 
      (fname, ftype, fid) = iprot.readFieldBegin()
12489 
      if ftype == TType.STOP:
12490 
        break
12491 
      if fid == 1:
12492 
        if ftype == TType.STRUCT:
12493 
          self.ex = TransactionServiceException()
12494 
          self.ex.read(iprot)
12495 
        else:
12496 
          iprot.skip(ftype)
12497 
      else:
12498 
        iprot.skip(ftype)
12499 
      iprot.readFieldEnd()
12500 
    iprot.readStructEnd()
12501 
 
12502 
  def write(self, oprot):
12503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12505 
      return
12506 
    oprot.writeStructBegin('addInvoiceNumber_result')
12507 
    if self.ex is not None:
12508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12509 
      self.ex.write(oprot)
12510 
      oprot.writeFieldEnd()
12511 
    oprot.writeFieldStop()
12512 
    oprot.writeStructEnd()
12513 
 
12514 
  def validate(self):
12515 
    return
12516 
 
12517 
 
12518 
  def __repr__(self):
12519 
    L = ['%s=%r' % (key, value)
12520 
      for key, value in self.__dict__.iteritems()]
12521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12522 
 
12523 
  def __eq__(self, other):
12524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12525 
 
12526 
  def __ne__(self, other):
12527 
    return not (self == other)
12528 
 
4910 phani.kuma 12529 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12530 
  """
12531 
  Attributes:
3064 chandransh 12532 
   - warehouseId
1408 ankur.sing 12533 
   - providerId
3064 chandransh 12534 
   - cod
4910 phani.kuma 12535 
   - orderIds
1408 ankur.sing 12536 
  """
12537 
 
12538 
  thrift_spec = (
12539 
    None, # 0
3064 chandransh 12540 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12541 
    (2, TType.I64, 'providerId', None, None, ), # 2
12542 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12543 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12544 
  )
12545 
 
4910 phani.kuma 12546 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12547 
    self.warehouseId = warehouseId
1408 ankur.sing 12548 
    self.providerId = providerId
3064 chandransh 12549 
    self.cod = cod
4910 phani.kuma 12550 
    self.orderIds = orderIds
1408 ankur.sing 12551 
 
12552 
  def read(self, iprot):
12553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12555 
      return
12556 
    iprot.readStructBegin()
12557 
    while True:
12558 
      (fname, ftype, fid) = iprot.readFieldBegin()
12559 
      if ftype == TType.STOP:
12560 
        break
12561 
      if fid == 1:
12562 
        if ftype == TType.I64:
3064 chandransh 12563 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12564 
        else:
12565 
          iprot.skip(ftype)
12566 
      elif fid == 2:
12567 
        if ftype == TType.I64:
3064 chandransh 12568 
          self.providerId = iprot.readI64();
1408 ankur.sing 12569 
        else:
12570 
          iprot.skip(ftype)
3064 chandransh 12571 
      elif fid == 3:
12572 
        if ftype == TType.BOOL:
12573 
          self.cod = iprot.readBool();
12574 
        else:
12575 
          iprot.skip(ftype)
4910 phani.kuma 12576 
      elif fid == 4:
12577 
        if ftype == TType.LIST:
12578 
          self.orderIds = []
5411 rajveer 12579 
          (_etype241, _size238) = iprot.readListBegin()
12580 
          for _i242 in xrange(_size238):
12581 
            _elem243 = iprot.readI64();
12582 
            self.orderIds.append(_elem243)
4910 phani.kuma 12583 
          iprot.readListEnd()
12584 
        else:
12585 
          iprot.skip(ftype)
1408 ankur.sing 12586 
      else:
12587 
        iprot.skip(ftype)
12588 
      iprot.readFieldEnd()
12589 
    iprot.readStructEnd()
12590 
 
12591 
  def write(self, oprot):
12592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12594 
      return
4910 phani.kuma 12595 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12596 
    if self.warehouseId is not None:
3064 chandransh 12597 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12598 
      oprot.writeI64(self.warehouseId)
12599 
      oprot.writeFieldEnd()
3431 rajveer 12600 
    if self.providerId is not None:
3064 chandransh 12601 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12602 
      oprot.writeI64(self.providerId)
12603 
      oprot.writeFieldEnd()
3431 rajveer 12604 
    if self.cod is not None:
3064 chandransh 12605 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12606 
      oprot.writeBool(self.cod)
1408 ankur.sing 12607 
      oprot.writeFieldEnd()
4910 phani.kuma 12608 
    if self.orderIds is not None:
12609 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12610 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12611 
      for iter244 in self.orderIds:
12612 
        oprot.writeI64(iter244)
4910 phani.kuma 12613 
      oprot.writeListEnd()
12614 
      oprot.writeFieldEnd()
1408 ankur.sing 12615 
    oprot.writeFieldStop()
12616 
    oprot.writeStructEnd()
12617 
 
3431 rajveer 12618 
  def validate(self):
12619 
    return
12620 
 
12621 
 
1408 ankur.sing 12622 
  def __repr__(self):
12623 
    L = ['%s=%r' % (key, value)
12624 
      for key, value in self.__dict__.iteritems()]
12625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12626 
 
12627 
  def __eq__(self, other):
12628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12629 
 
12630 
  def __ne__(self, other):
12631 
    return not (self == other)
12632 
 
4910 phani.kuma 12633 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12634 
  """
12635 
  Attributes:
12636 
   - success
3064 chandransh 12637 
   - ex
1408 ankur.sing 12638 
  """
12639 
 
12640 
  thrift_spec = (
3064 chandransh 12641 
    (0, TType.BOOL, 'success', None, None, ), # 0
12642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12643 
  )
12644 
 
3064 chandransh 12645 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12646 
    self.success = success
3064 chandransh 12647 
    self.ex = ex
1408 ankur.sing 12648 
 
12649 
  def read(self, iprot):
12650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12652 
      return
12653 
    iprot.readStructBegin()
12654 
    while True:
12655 
      (fname, ftype, fid) = iprot.readFieldBegin()
12656 
      if ftype == TType.STOP:
12657 
        break
12658 
      if fid == 0:
3064 chandransh 12659 
        if ftype == TType.BOOL:
12660 
          self.success = iprot.readBool();
1408 ankur.sing 12661 
        else:
12662 
          iprot.skip(ftype)
3064 chandransh 12663 
      elif fid == 1:
12664 
        if ftype == TType.STRUCT:
12665 
          self.ex = TransactionServiceException()
12666 
          self.ex.read(iprot)
12667 
        else:
12668 
          iprot.skip(ftype)
1408 ankur.sing 12669 
      else:
12670 
        iprot.skip(ftype)
12671 
      iprot.readFieldEnd()
12672 
    iprot.readStructEnd()
12673 
 
12674 
  def write(self, oprot):
12675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12677 
      return
4910 phani.kuma 12678 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12679 
    if self.success is not None:
3064 chandransh 12680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12681 
      oprot.writeBool(self.success)
1408 ankur.sing 12682 
      oprot.writeFieldEnd()
3431 rajveer 12683 
    if self.ex is not None:
3064 chandransh 12684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12685 
      self.ex.write(oprot)
12686 
      oprot.writeFieldEnd()
1408 ankur.sing 12687 
    oprot.writeFieldStop()
12688 
    oprot.writeStructEnd()
12689 
 
3431 rajveer 12690 
  def validate(self):
12691 
    return
12692 
 
12693 
 
1408 ankur.sing 12694 
  def __repr__(self):
12695 
    L = ['%s=%r' % (key, value)
12696 
      for key, value in self.__dict__.iteritems()]
12697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12698 
 
12699 
  def __eq__(self, other):
12700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12701 
 
12702 
  def __ne__(self, other):
12703 
    return not (self == other)
12704 
 
4910 phani.kuma 12705 
class markOrdersAsPickedUp_args:
4410 rajveer 12706 
  """
12707 
  Attributes:
12708 
   - providerId
4910 phani.kuma 12709 
   - pickupDetails
4410 rajveer 12710 
  """
12711 
 
12712 
  thrift_spec = (
12713 
    None, # 0
4910 phani.kuma 12714 
    (1, TType.I64, 'providerId', None, None, ), # 1
12715 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12716 
  )
12717 
 
4910 phani.kuma 12718 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12719 
    self.providerId = providerId
4910 phani.kuma 12720 
    self.pickupDetails = pickupDetails
4410 rajveer 12721 
 
12722 
  def read(self, iprot):
12723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12725 
      return
12726 
    iprot.readStructBegin()
12727 
    while True:
12728 
      (fname, ftype, fid) = iprot.readFieldBegin()
12729 
      if ftype == TType.STOP:
12730 
        break
12731 
      if fid == 1:
12732 
        if ftype == TType.I64:
4910 phani.kuma 12733 
          self.providerId = iprot.readI64();
4410 rajveer 12734 
        else:
12735 
          iprot.skip(ftype)
12736 
      elif fid == 2:
4910 phani.kuma 12737 
        if ftype == TType.MAP:
12738 
          self.pickupDetails = {}
5411 rajveer 12739 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12740 
          for _i249 in xrange(_size245):
12741 
            _key250 = iprot.readString();
12742 
            _val251 = iprot.readString();
12743 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12744 
          iprot.readMapEnd()
4410 rajveer 12745 
        else:
12746 
          iprot.skip(ftype)
12747 
      else:
12748 
        iprot.skip(ftype)
12749 
      iprot.readFieldEnd()
12750 
    iprot.readStructEnd()
12751 
 
12752 
  def write(self, oprot):
12753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12755 
      return
4910 phani.kuma 12756 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12757 
    if self.providerId is not None:
4910 phani.kuma 12758 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12759 
      oprot.writeI64(self.providerId)
12760 
      oprot.writeFieldEnd()
4910 phani.kuma 12761 
    if self.pickupDetails is not None:
12762 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12763 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12764 
      for kiter252,viter253 in self.pickupDetails.items():
12765 
        oprot.writeString(kiter252)
12766 
        oprot.writeString(viter253)
4910 phani.kuma 12767 
      oprot.writeMapEnd()
4410 rajveer 12768 
      oprot.writeFieldEnd()
12769 
    oprot.writeFieldStop()
12770 
    oprot.writeStructEnd()
12771 
 
12772 
  def validate(self):
12773 
    return
12774 
 
12775 
 
12776 
  def __repr__(self):
12777 
    L = ['%s=%r' % (key, value)
12778 
      for key, value in self.__dict__.iteritems()]
12779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12780 
 
12781 
  def __eq__(self, other):
12782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12783 
 
12784 
  def __ne__(self, other):
12785 
    return not (self == other)
12786 
 
4910 phani.kuma 12787 
class markOrdersAsPickedUp_result:
4410 rajveer 12788 
  """
12789 
  Attributes:
12790 
   - ex
12791 
  """
12792 
 
12793 
  thrift_spec = (
4910 phani.kuma 12794 
    None, # 0
4410 rajveer 12795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12796 
  )
12797 
 
4910 phani.kuma 12798 
  def __init__(self, ex=None,):
4410 rajveer 12799 
    self.ex = ex
12800 
 
12801 
  def read(self, iprot):
12802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12804 
      return
12805 
    iprot.readStructBegin()
12806 
    while True:
12807 
      (fname, ftype, fid) = iprot.readFieldBegin()
12808 
      if ftype == TType.STOP:
12809 
        break
4910 phani.kuma 12810 
      if fid == 1:
4410 rajveer 12811 
        if ftype == TType.STRUCT:
12812 
          self.ex = TransactionServiceException()
12813 
          self.ex.read(iprot)
12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      else:
12817 
        iprot.skip(ftype)
12818 
      iprot.readFieldEnd()
12819 
    iprot.readStructEnd()
12820 
 
12821 
  def write(self, oprot):
12822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12824 
      return
4910 phani.kuma 12825 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12826 
    if self.ex is not None:
12827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12828 
      self.ex.write(oprot)
12829 
      oprot.writeFieldEnd()
12830 
    oprot.writeFieldStop()
12831 
    oprot.writeStructEnd()
12832 
 
12833 
  def validate(self):
12834 
    return
12835 
 
12836 
 
12837 
  def __repr__(self):
12838 
    L = ['%s=%r' % (key, value)
12839 
      for key, value in self.__dict__.iteritems()]
12840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12841 
 
12842 
  def __eq__(self, other):
12843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12844 
 
12845 
  def __ne__(self, other):
12846 
    return not (self == other)
12847 
 
4910 phani.kuma 12848 
class getOrdersNotPickedUp_args:
304 ashish 12849 
  """
12850 
  Attributes:
3064 chandransh 12851 
   - providerId
304 ashish 12852 
  """
94 ashish 12853 
 
304 ashish 12854 
  thrift_spec = (
12855 
    None, # 0
3064 chandransh 12856 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12857 
  )
12858 
 
4910 phani.kuma 12859 
  def __init__(self, providerId=None,):
3064 chandransh 12860 
    self.providerId = providerId
304 ashish 12861 
 
12862 
  def read(self, iprot):
12863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12865 
      return
12866 
    iprot.readStructBegin()
12867 
    while True:
12868 
      (fname, ftype, fid) = iprot.readFieldBegin()
12869 
      if ftype == TType.STOP:
12870 
        break
12871 
      if fid == 1:
12872 
        if ftype == TType.I64:
3064 chandransh 12873 
          self.providerId = iprot.readI64();
304 ashish 12874 
        else:
12875 
          iprot.skip(ftype)
12876 
      else:
12877 
        iprot.skip(ftype)
12878 
      iprot.readFieldEnd()
12879 
    iprot.readStructEnd()
12880 
 
12881 
  def write(self, oprot):
12882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12884 
      return
4910 phani.kuma 12885 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12886 
    if self.providerId is not None:
3064 chandransh 12887 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12888 
      oprot.writeI64(self.providerId)
304 ashish 12889 
      oprot.writeFieldEnd()
12890 
    oprot.writeFieldStop()
12891 
    oprot.writeStructEnd()
12892 
 
3431 rajveer 12893 
  def validate(self):
12894 
    return
12895 
 
12896 
 
304 ashish 12897 
  def __repr__(self):
12898 
    L = ['%s=%r' % (key, value)
12899 
      for key, value in self.__dict__.iteritems()]
12900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12901 
 
12902 
  def __eq__(self, other):
12903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12904 
 
12905 
  def __ne__(self, other):
12906 
    return not (self == other)
12907 
 
4910 phani.kuma 12908 
class getOrdersNotPickedUp_result:
304 ashish 12909 
  """
12910 
  Attributes:
12911 
   - success
12912 
  """
12913 
 
12914 
  thrift_spec = (
3064 chandransh 12915 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12916 
  )
12917 
 
4910 phani.kuma 12918 
  def __init__(self, success=None,):
304 ashish 12919 
    self.success = success
12920 
 
12921 
  def read(self, iprot):
12922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12924 
      return
12925 
    iprot.readStructBegin()
12926 
    while True:
12927 
      (fname, ftype, fid) = iprot.readFieldBegin()
12928 
      if ftype == TType.STOP:
12929 
        break
12930 
      if fid == 0:
12931 
        if ftype == TType.LIST:
12932 
          self.success = []
5411 rajveer 12933 
          (_etype257, _size254) = iprot.readListBegin()
12934 
          for _i258 in xrange(_size254):
12935 
            _elem259 = Order()
12936 
            _elem259.read(iprot)
12937 
            self.success.append(_elem259)
304 ashish 12938 
          iprot.readListEnd()
12939 
        else:
12940 
          iprot.skip(ftype)
12941 
      else:
12942 
        iprot.skip(ftype)
12943 
      iprot.readFieldEnd()
12944 
    iprot.readStructEnd()
12945 
 
12946 
  def write(self, oprot):
12947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12949 
      return
4910 phani.kuma 12950 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12951 
    if self.success is not None:
304 ashish 12952 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12953 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12954 
      for iter260 in self.success:
12955 
        iter260.write(oprot)
304 ashish 12956 
      oprot.writeListEnd()
12957 
      oprot.writeFieldEnd()
12958 
    oprot.writeFieldStop()
12959 
    oprot.writeStructEnd()
12960 
 
3431 rajveer 12961 
  def validate(self):
12962 
    return
12963 
 
12964 
 
304 ashish 12965 
  def __repr__(self):
12966 
    L = ['%s=%r' % (key, value)
12967 
      for key, value in self.__dict__.iteritems()]
12968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12969 
 
12970 
  def __eq__(self, other):
12971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12972 
 
12973 
  def __ne__(self, other):
12974 
    return not (self == other)
12975 
 
3064 chandransh 12976 
class markOrdersAsDelivered_args:
304 ashish 12977 
  """
12978 
  Attributes:
3064 chandransh 12979 
   - providerId
12980 
   - deliveredOrders
304 ashish 12981 
  """
12982 
 
12983 
  thrift_spec = (
12984 
    None, # 0
3064 chandransh 12985 
    (1, TType.I64, 'providerId', None, None, ), # 1
12986 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12987 
  )
12988 
 
3064 chandransh 12989 
  def __init__(self, providerId=None, deliveredOrders=None,):
12990 
    self.providerId = providerId
12991 
    self.deliveredOrders = deliveredOrders
304 ashish 12992 
 
12993 
  def read(self, iprot):
12994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12996 
      return
12997 
    iprot.readStructBegin()
12998 
    while True:
12999 
      (fname, ftype, fid) = iprot.readFieldBegin()
13000 
      if ftype == TType.STOP:
13001 
        break
13002 
      if fid == 1:
13003 
        if ftype == TType.I64:
3064 chandransh 13004 
          self.providerId = iprot.readI64();
304 ashish 13005 
        else:
13006 
          iprot.skip(ftype)
13007 
      elif fid == 2:
3064 chandransh 13008 
        if ftype == TType.MAP:
13009 
          self.deliveredOrders = {}
5411 rajveer 13010 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
13011 
          for _i265 in xrange(_size261):
13012 
            _key266 = iprot.readString();
13013 
            _val267 = iprot.readString();
13014 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 13015 
          iprot.readMapEnd()
304 ashish 13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
3064 chandransh 13027 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13028 
    if self.providerId is not None:
3064 chandransh 13029 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13030 
      oprot.writeI64(self.providerId)
304 ashish 13031 
      oprot.writeFieldEnd()
3431 rajveer 13032 
    if self.deliveredOrders is not None:
3064 chandransh 13033 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13034 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 13035 
      for kiter268,viter269 in self.deliveredOrders.items():
13036 
        oprot.writeString(kiter268)
13037 
        oprot.writeString(viter269)
3064 chandransh 13038 
      oprot.writeMapEnd()
304 ashish 13039 
      oprot.writeFieldEnd()
13040 
    oprot.writeFieldStop()
13041 
    oprot.writeStructEnd()
13042 
 
3431 rajveer 13043 
  def validate(self):
13044 
    return
13045 
 
13046 
 
304 ashish 13047 
  def __repr__(self):
13048 
    L = ['%s=%r' % (key, value)
13049 
      for key, value in self.__dict__.iteritems()]
13050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13051 
 
13052 
  def __eq__(self, other):
13053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13054 
 
13055 
  def __ne__(self, other):
13056 
    return not (self == other)
13057 
 
3064 chandransh 13058 
class markOrdersAsDelivered_result:
13059 
  """
13060 
  Attributes:
13061 
   - ex
13062 
  """
304 ashish 13063 
 
13064 
  thrift_spec = (
3064 chandransh 13065 
    None, # 0
13066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13067 
  )
13068 
 
3064 chandransh 13069 
  def __init__(self, ex=None,):
13070 
    self.ex = ex
304 ashish 13071 
 
1596 ankur.sing 13072 
  def read(self, iprot):
13073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13075 
      return
13076 
    iprot.readStructBegin()
13077 
    while True:
13078 
      (fname, ftype, fid) = iprot.readFieldBegin()
13079 
      if ftype == TType.STOP:
13080 
        break
3064 chandransh 13081 
      if fid == 1:
13082 
        if ftype == TType.STRUCT:
13083 
          self.ex = TransactionServiceException()
13084 
          self.ex.read(iprot)
13085 
        else:
13086 
          iprot.skip(ftype)
1596 ankur.sing 13087 
      else:
13088 
        iprot.skip(ftype)
13089 
      iprot.readFieldEnd()
13090 
    iprot.readStructEnd()
13091 
 
13092 
  def write(self, oprot):
13093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13095 
      return
3064 chandransh 13096 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13097 
    if self.ex is not None:
3064 chandransh 13098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13099 
      self.ex.write(oprot)
13100 
      oprot.writeFieldEnd()
1596 ankur.sing 13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
3431 rajveer 13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
1596 ankur.sing 13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
4910 phani.kuma 13119 
class markAsRTOrders_args:
1596 ankur.sing 13120 
  """
13121 
  Attributes:
3064 chandransh 13122 
   - providerId
13123 
   - returnedOrders
1596 ankur.sing 13124 
  """
13125 
 
13126 
  thrift_spec = (
3064 chandransh 13127 
    None, # 0
13128 
    (1, TType.I64, 'providerId', None, None, ), # 1
13129 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13130 
  )
13131 
 
3064 chandransh 13132 
  def __init__(self, providerId=None, returnedOrders=None,):
13133 
    self.providerId = providerId
13134 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13135 
 
13136 
  def read(self, iprot):
13137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13139 
      return
13140 
    iprot.readStructBegin()
13141 
    while True:
13142 
      (fname, ftype, fid) = iprot.readFieldBegin()
13143 
      if ftype == TType.STOP:
13144 
        break
3064 chandransh 13145 
      if fid == 1:
1596 ankur.sing 13146 
        if ftype == TType.I64:
3064 chandransh 13147 
          self.providerId = iprot.readI64();
1596 ankur.sing 13148 
        else:
13149 
          iprot.skip(ftype)
3064 chandransh 13150 
      elif fid == 2:
13151 
        if ftype == TType.MAP:
13152 
          self.returnedOrders = {}
5411 rajveer 13153 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
13154 
          for _i274 in xrange(_size270):
13155 
            _key275 = iprot.readString();
13156 
            _val276 = iprot.readString();
13157 
            self.returnedOrders[_key275] = _val276
3064 chandransh 13158 
          iprot.readMapEnd()
13159 
        else:
13160 
          iprot.skip(ftype)
1596 ankur.sing 13161 
      else:
13162 
        iprot.skip(ftype)
13163 
      iprot.readFieldEnd()
13164 
    iprot.readStructEnd()
13165 
 
13166 
  def write(self, oprot):
13167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13169 
      return
4910 phani.kuma 13170 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13171 
    if self.providerId is not None:
3064 chandransh 13172 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13173 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13174 
      oprot.writeFieldEnd()
3431 rajveer 13175 
    if self.returnedOrders is not None:
3064 chandransh 13176 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13177 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 13178 
      for kiter277,viter278 in self.returnedOrders.items():
13179 
        oprot.writeString(kiter277)
13180 
        oprot.writeString(viter278)
3064 chandransh 13181 
      oprot.writeMapEnd()
13182 
      oprot.writeFieldEnd()
1596 ankur.sing 13183 
    oprot.writeFieldStop()
13184 
    oprot.writeStructEnd()
13185 
 
3431 rajveer 13186 
  def validate(self):
13187 
    return
13188 
 
13189 
 
1596 ankur.sing 13190 
  def __repr__(self):
13191 
    L = ['%s=%r' % (key, value)
13192 
      for key, value in self.__dict__.iteritems()]
13193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13194 
 
13195 
  def __eq__(self, other):
13196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13197 
 
13198 
  def __ne__(self, other):
13199 
    return not (self == other)
13200 
 
4910 phani.kuma 13201 
class markAsRTOrders_result:
3064 chandransh 13202 
  """
13203 
  Attributes:
13204 
   - ex
13205 
  """
1596 ankur.sing 13206 
 
1627 ankur.sing 13207 
  thrift_spec = (
3064 chandransh 13208 
    None, # 0
13209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13210 
  )
13211 
 
3064 chandransh 13212 
  def __init__(self, ex=None,):
13213 
    self.ex = ex
13214 
 
1627 ankur.sing 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
3064 chandransh 13224 
      if fid == 1:
13225 
        if ftype == TType.STRUCT:
13226 
          self.ex = TransactionServiceException()
13227 
          self.ex.read(iprot)
13228 
        else:
13229 
          iprot.skip(ftype)
1627 ankur.sing 13230 
      else:
13231 
        iprot.skip(ftype)
13232 
      iprot.readFieldEnd()
13233 
    iprot.readStructEnd()
13234 
 
13235 
  def write(self, oprot):
13236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13238 
      return
4910 phani.kuma 13239 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13240 
    if self.ex is not None:
3064 chandransh 13241 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13242 
      self.ex.write(oprot)
13243 
      oprot.writeFieldEnd()
1627 ankur.sing 13244 
    oprot.writeFieldStop()
13245 
    oprot.writeStructEnd()
13246 
 
3431 rajveer 13247 
  def validate(self):
13248 
    return
13249 
 
13250 
 
1627 ankur.sing 13251 
  def __repr__(self):
13252 
    L = ['%s=%r' % (key, value)
13253 
      for key, value in self.__dict__.iteritems()]
13254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13255 
 
13256 
  def __eq__(self, other):
13257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13258 
 
13259 
  def __ne__(self, other):
13260 
    return not (self == other)
13261 
 
4910 phani.kuma 13262 
class getRTOrders_args:
13263 
  """
13264 
  Attributes:
13265 
   - providerId
13266 
  """
13267 
 
13268 
  thrift_spec = (
13269 
    None, # 0
13270 
    (1, TType.I64, 'providerId', None, None, ), # 1
13271 
  )
13272 
 
13273 
  def __init__(self, providerId=None,):
13274 
    self.providerId = providerId
13275 
 
13276 
  def read(self, iprot):
13277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13279 
      return
13280 
    iprot.readStructBegin()
13281 
    while True:
13282 
      (fname, ftype, fid) = iprot.readFieldBegin()
13283 
      if ftype == TType.STOP:
13284 
        break
13285 
      if fid == 1:
13286 
        if ftype == TType.I64:
13287 
          self.providerId = iprot.readI64();
13288 
        else:
13289 
          iprot.skip(ftype)
13290 
      else:
13291 
        iprot.skip(ftype)
13292 
      iprot.readFieldEnd()
13293 
    iprot.readStructEnd()
13294 
 
13295 
  def write(self, oprot):
13296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13298 
      return
13299 
    oprot.writeStructBegin('getRTOrders_args')
13300 
    if self.providerId is not None:
13301 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13302 
      oprot.writeI64(self.providerId)
13303 
      oprot.writeFieldEnd()
13304 
    oprot.writeFieldStop()
13305 
    oprot.writeStructEnd()
13306 
 
13307 
  def validate(self):
13308 
    return
13309 
 
13310 
 
13311 
  def __repr__(self):
13312 
    L = ['%s=%r' % (key, value)
13313 
      for key, value in self.__dict__.iteritems()]
13314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13315 
 
13316 
  def __eq__(self, other):
13317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13318 
 
13319 
  def __ne__(self, other):
13320 
    return not (self == other)
13321 
 
13322 
class getRTOrders_result:
13323 
  """
13324 
  Attributes:
13325 
   - success
13326 
  """
13327 
 
13328 
  thrift_spec = (
13329 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13330 
  )
13331 
 
13332 
  def __init__(self, success=None,):
13333 
    self.success = success
13334 
 
13335 
  def read(self, iprot):
13336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13338 
      return
13339 
    iprot.readStructBegin()
13340 
    while True:
13341 
      (fname, ftype, fid) = iprot.readFieldBegin()
13342 
      if ftype == TType.STOP:
13343 
        break
13344 
      if fid == 0:
13345 
        if ftype == TType.LIST:
13346 
          self.success = []
5411 rajveer 13347 
          (_etype282, _size279) = iprot.readListBegin()
13348 
          for _i283 in xrange(_size279):
13349 
            _elem284 = Order()
13350 
            _elem284.read(iprot)
13351 
            self.success.append(_elem284)
4910 phani.kuma 13352 
          iprot.readListEnd()
13353 
        else:
13354 
          iprot.skip(ftype)
13355 
      else:
13356 
        iprot.skip(ftype)
13357 
      iprot.readFieldEnd()
13358 
    iprot.readStructEnd()
13359 
 
13360 
  def write(self, oprot):
13361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13363 
      return
13364 
    oprot.writeStructBegin('getRTOrders_result')
13365 
    if self.success is not None:
13366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13368 
      for iter285 in self.success:
13369 
        iter285.write(oprot)
4910 phani.kuma 13370 
      oprot.writeListEnd()
13371 
      oprot.writeFieldEnd()
13372 
    oprot.writeFieldStop()
13373 
    oprot.writeStructEnd()
13374 
 
13375 
  def validate(self):
13376 
    return
13377 
 
13378 
 
13379 
  def __repr__(self):
13380 
    L = ['%s=%r' % (key, value)
13381 
      for key, value in self.__dict__.iteritems()]
13382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13383 
 
13384 
  def __eq__(self, other):
13385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13386 
 
13387 
  def __ne__(self, other):
13388 
    return not (self == other)
13389 
 
3064 chandransh 13390 
class updateNonDeliveryReason_args:
1627 ankur.sing 13391 
  """
13392 
  Attributes:
3064 chandransh 13393 
   - providerId
13394 
   - undeliveredOrders
1627 ankur.sing 13395 
  """
13396 
 
13397 
  thrift_spec = (
3064 chandransh 13398 
    None, # 0
13399 
    (1, TType.I64, 'providerId', None, None, ), # 1
13400 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13401 
  )
13402 
 
3064 chandransh 13403 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13404 
    self.providerId = providerId
13405 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13406 
 
13407 
  def read(self, iprot):
13408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13410 
      return
13411 
    iprot.readStructBegin()
13412 
    while True:
13413 
      (fname, ftype, fid) = iprot.readFieldBegin()
13414 
      if ftype == TType.STOP:
13415 
        break
3064 chandransh 13416 
      if fid == 1:
1627 ankur.sing 13417 
        if ftype == TType.I64:
3064 chandransh 13418 
          self.providerId = iprot.readI64();
1627 ankur.sing 13419 
        else:
13420 
          iprot.skip(ftype)
3064 chandransh 13421 
      elif fid == 2:
13422 
        if ftype == TType.MAP:
13423 
          self.undeliveredOrders = {}
5411 rajveer 13424 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
13425 
          for _i290 in xrange(_size286):
13426 
            _key291 = iprot.readString();
13427 
            _val292 = iprot.readString();
13428 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 13429 
          iprot.readMapEnd()
13430 
        else:
13431 
          iprot.skip(ftype)
1627 ankur.sing 13432 
      else:
13433 
        iprot.skip(ftype)
13434 
      iprot.readFieldEnd()
13435 
    iprot.readStructEnd()
13436 
 
13437 
  def write(self, oprot):
13438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13440 
      return
3064 chandransh 13441 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13442 
    if self.providerId is not None:
3064 chandransh 13443 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13444 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13445 
      oprot.writeFieldEnd()
3431 rajveer 13446 
    if self.undeliveredOrders is not None:
3064 chandransh 13447 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13448 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 13449 
      for kiter293,viter294 in self.undeliveredOrders.items():
13450 
        oprot.writeString(kiter293)
13451 
        oprot.writeString(viter294)
3064 chandransh 13452 
      oprot.writeMapEnd()
13453 
      oprot.writeFieldEnd()
1627 ankur.sing 13454 
    oprot.writeFieldStop()
13455 
    oprot.writeStructEnd()
13456 
 
3431 rajveer 13457 
  def validate(self):
13458 
    return
13459 
 
13460 
 
1627 ankur.sing 13461 
  def __repr__(self):
13462 
    L = ['%s=%r' % (key, value)
13463 
      for key, value in self.__dict__.iteritems()]
13464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13465 
 
13466 
  def __eq__(self, other):
13467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13468 
 
13469 
  def __ne__(self, other):
13470 
    return not (self == other)
13471 
 
3064 chandransh 13472 
class updateNonDeliveryReason_result:
1627 ankur.sing 13473 
  """
13474 
  Attributes:
3064 chandransh 13475 
   - ex
1627 ankur.sing 13476 
  """
13477 
 
13478 
  thrift_spec = (
4910 phani.kuma 13479 
    None, # 0
3064 chandransh 13480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13481 
  )
13482 
 
4910 phani.kuma 13483 
  def __init__(self, ex=None,):
3064 chandransh 13484 
    self.ex = ex
1627 ankur.sing 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
4910 phani.kuma 13495 
      if fid == 1:
13496 
        if ftype == TType.STRUCT:
13497 
          self.ex = TransactionServiceException()
13498 
          self.ex.read(iprot)
13499 
        else:
13500 
          iprot.skip(ftype)
13501 
      else:
13502 
        iprot.skip(ftype)
13503 
      iprot.readFieldEnd()
13504 
    iprot.readStructEnd()
13505 
 
13506 
  def write(self, oprot):
13507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13509 
      return
13510 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13511 
    if self.ex is not None:
13512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13513 
      self.ex.write(oprot)
13514 
      oprot.writeFieldEnd()
13515 
    oprot.writeFieldStop()
13516 
    oprot.writeStructEnd()
13517 
 
13518 
  def validate(self):
13519 
    return
13520 
 
13521 
 
13522 
  def __repr__(self):
13523 
    L = ['%s=%r' % (key, value)
13524 
      for key, value in self.__dict__.iteritems()]
13525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13526 
 
13527 
  def __eq__(self, other):
13528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13529 
 
13530 
  def __ne__(self, other):
13531 
    return not (self == other)
13532 
 
13533 
class getNonDeliveredOrdersbyCourier_args:
13534 
  """
13535 
  Attributes:
13536 
   - providerId
13537 
  """
13538 
 
13539 
  thrift_spec = (
13540 
    None, # 0
13541 
    (1, TType.I64, 'providerId', None, None, ), # 1
13542 
  )
13543 
 
13544 
  def __init__(self, providerId=None,):
13545 
    self.providerId = providerId
13546 
 
13547 
  def read(self, iprot):
13548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13550 
      return
13551 
    iprot.readStructBegin()
13552 
    while True:
13553 
      (fname, ftype, fid) = iprot.readFieldBegin()
13554 
      if ftype == TType.STOP:
13555 
        break
13556 
      if fid == 1:
13557 
        if ftype == TType.I64:
13558 
          self.providerId = iprot.readI64();
13559 
        else:
13560 
          iprot.skip(ftype)
13561 
      else:
13562 
        iprot.skip(ftype)
13563 
      iprot.readFieldEnd()
13564 
    iprot.readStructEnd()
13565 
 
13566 
  def write(self, oprot):
13567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13569 
      return
13570 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13571 
    if self.providerId is not None:
13572 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13573 
      oprot.writeI64(self.providerId)
13574 
      oprot.writeFieldEnd()
13575 
    oprot.writeFieldStop()
13576 
    oprot.writeStructEnd()
13577 
 
13578 
  def validate(self):
13579 
    return
13580 
 
13581 
 
13582 
  def __repr__(self):
13583 
    L = ['%s=%r' % (key, value)
13584 
      for key, value in self.__dict__.iteritems()]
13585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13586 
 
13587 
  def __eq__(self, other):
13588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13589 
 
13590 
  def __ne__(self, other):
13591 
    return not (self == other)
13592 
 
13593 
class getNonDeliveredOrdersbyCourier_result:
13594 
  """
13595 
  Attributes:
13596 
   - success
13597 
  """
13598 
 
13599 
  thrift_spec = (
13600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13601 
  )
13602 
 
13603 
  def __init__(self, success=None,):
13604 
    self.success = success
13605 
 
13606 
  def read(self, iprot):
13607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13609 
      return
13610 
    iprot.readStructBegin()
13611 
    while True:
13612 
      (fname, ftype, fid) = iprot.readFieldBegin()
13613 
      if ftype == TType.STOP:
13614 
        break
4581 phani.kuma 13615 
      if fid == 0:
13616 
        if ftype == TType.LIST:
13617 
          self.success = []
5411 rajveer 13618 
          (_etype298, _size295) = iprot.readListBegin()
13619 
          for _i299 in xrange(_size295):
13620 
            _elem300 = Order()
13621 
            _elem300.read(iprot)
13622 
            self.success.append(_elem300)
4581 phani.kuma 13623 
          iprot.readListEnd()
13624 
        else:
13625 
          iprot.skip(ftype)
4910 phani.kuma 13626 
      else:
13627 
        iprot.skip(ftype)
13628 
      iprot.readFieldEnd()
13629 
    iprot.readStructEnd()
13630 
 
13631 
  def write(self, oprot):
13632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13634 
      return
13635 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13636 
    if self.success is not None:
13637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13639 
      for iter301 in self.success:
13640 
        iter301.write(oprot)
4910 phani.kuma 13641 
      oprot.writeListEnd()
13642 
      oprot.writeFieldEnd()
13643 
    oprot.writeFieldStop()
13644 
    oprot.writeStructEnd()
13645 
 
13646 
  def validate(self):
13647 
    return
13648 
 
13649 
 
13650 
  def __repr__(self):
13651 
    L = ['%s=%r' % (key, value)
13652 
      for key, value in self.__dict__.iteritems()]
13653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13654 
 
13655 
  def __eq__(self, other):
13656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13657 
 
13658 
  def __ne__(self, other):
13659 
    return not (self == other)
13660 
 
13661 
class markOrdersAsLocalConnected_args:
13662 
  """
13663 
  Attributes:
13664 
   - providerId
13665 
   - local_connected_orders
13666 
  """
13667 
 
13668 
  thrift_spec = (
13669 
    None, # 0
13670 
    (1, TType.I64, 'providerId', None, None, ), # 1
13671 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13672 
  )
13673 
 
13674 
  def __init__(self, providerId=None, local_connected_orders=None,):
13675 
    self.providerId = providerId
13676 
    self.local_connected_orders = local_connected_orders
13677 
 
13678 
  def read(self, iprot):
13679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13681 
      return
13682 
    iprot.readStructBegin()
13683 
    while True:
13684 
      (fname, ftype, fid) = iprot.readFieldBegin()
13685 
      if ftype == TType.STOP:
13686 
        break
13687 
      if fid == 1:
13688 
        if ftype == TType.I64:
13689 
          self.providerId = iprot.readI64();
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      elif fid == 2:
13693 
        if ftype == TType.MAP:
13694 
          self.local_connected_orders = {}
5411 rajveer 13695 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13696 
          for _i306 in xrange(_size302):
13697 
            _key307 = iprot.readString();
13698 
            _val308 = iprot.readString();
13699 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13700 
          iprot.readMapEnd()
13701 
        else:
13702 
          iprot.skip(ftype)
13703 
      else:
13704 
        iprot.skip(ftype)
13705 
      iprot.readFieldEnd()
13706 
    iprot.readStructEnd()
13707 
 
13708 
  def write(self, oprot):
13709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13711 
      return
13712 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13713 
    if self.providerId is not None:
13714 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13715 
      oprot.writeI64(self.providerId)
13716 
      oprot.writeFieldEnd()
13717 
    if self.local_connected_orders is not None:
13718 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13719 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13720 
      for kiter309,viter310 in self.local_connected_orders.items():
13721 
        oprot.writeString(kiter309)
13722 
        oprot.writeString(viter310)
4910 phani.kuma 13723 
      oprot.writeMapEnd()
13724 
      oprot.writeFieldEnd()
13725 
    oprot.writeFieldStop()
13726 
    oprot.writeStructEnd()
13727 
 
13728 
  def validate(self):
13729 
    return
13730 
 
13731 
 
13732 
  def __repr__(self):
13733 
    L = ['%s=%r' % (key, value)
13734 
      for key, value in self.__dict__.iteritems()]
13735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13736 
 
13737 
  def __eq__(self, other):
13738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13739 
 
13740 
  def __ne__(self, other):
13741 
    return not (self == other)
13742 
 
13743 
class markOrdersAsLocalConnected_result:
13744 
  """
13745 
  Attributes:
13746 
   - ex
13747 
  """
13748 
 
13749 
  thrift_spec = (
13750 
    None, # 0
13751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13752 
  )
13753 
 
13754 
  def __init__(self, ex=None,):
13755 
    self.ex = ex
13756 
 
13757 
  def read(self, iprot):
13758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13760 
      return
13761 
    iprot.readStructBegin()
13762 
    while True:
13763 
      (fname, ftype, fid) = iprot.readFieldBegin()
13764 
      if ftype == TType.STOP:
13765 
        break
13766 
      if fid == 1:
3064 chandransh 13767 
        if ftype == TType.STRUCT:
13768 
          self.ex = TransactionServiceException()
13769 
          self.ex.read(iprot)
1627 ankur.sing 13770 
        else:
13771 
          iprot.skip(ftype)
13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
4910 phani.kuma 13781 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13782 
    if self.ex is not None:
13783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13784 
      self.ex.write(oprot)
13785 
      oprot.writeFieldEnd()
13786 
    oprot.writeFieldStop()
13787 
    oprot.writeStructEnd()
13788 
 
13789 
  def validate(self):
13790 
    return
13791 
 
13792 
 
13793 
  def __repr__(self):
13794 
    L = ['%s=%r' % (key, value)
13795 
      for key, value in self.__dict__.iteritems()]
13796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13797 
 
13798 
  def __eq__(self, other):
13799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13800 
 
13801 
  def __ne__(self, other):
13802 
    return not (self == other)
13803 
 
13804 
class getOrdersNotLocalConnected_args:
13805 
  """
13806 
  Attributes:
13807 
   - providerId
13808 
  """
13809 
 
13810 
  thrift_spec = (
13811 
    None, # 0
13812 
    (1, TType.I64, 'providerId', None, None, ), # 1
13813 
  )
13814 
 
13815 
  def __init__(self, providerId=None,):
13816 
    self.providerId = providerId
13817 
 
13818 
  def read(self, iprot):
13819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13821 
      return
13822 
    iprot.readStructBegin()
13823 
    while True:
13824 
      (fname, ftype, fid) = iprot.readFieldBegin()
13825 
      if ftype == TType.STOP:
13826 
        break
13827 
      if fid == 1:
13828 
        if ftype == TType.I64:
13829 
          self.providerId = iprot.readI64();
13830 
        else:
13831 
          iprot.skip(ftype)
13832 
      else:
13833 
        iprot.skip(ftype)
13834 
      iprot.readFieldEnd()
13835 
    iprot.readStructEnd()
13836 
 
13837 
  def write(self, oprot):
13838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13840 
      return
13841 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13842 
    if self.providerId is not None:
13843 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13844 
      oprot.writeI64(self.providerId)
13845 
      oprot.writeFieldEnd()
13846 
    oprot.writeFieldStop()
13847 
    oprot.writeStructEnd()
13848 
 
13849 
  def validate(self):
13850 
    return
13851 
 
13852 
 
13853 
  def __repr__(self):
13854 
    L = ['%s=%r' % (key, value)
13855 
      for key, value in self.__dict__.iteritems()]
13856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13857 
 
13858 
  def __eq__(self, other):
13859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13860 
 
13861 
  def __ne__(self, other):
13862 
    return not (self == other)
13863 
 
13864 
class getOrdersNotLocalConnected_result:
13865 
  """
13866 
  Attributes:
13867 
   - success
13868 
  """
13869 
 
13870 
  thrift_spec = (
13871 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13872 
  )
13873 
 
13874 
  def __init__(self, success=None,):
13875 
    self.success = success
13876 
 
13877 
  def read(self, iprot):
13878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13880 
      return
13881 
    iprot.readStructBegin()
13882 
    while True:
13883 
      (fname, ftype, fid) = iprot.readFieldBegin()
13884 
      if ftype == TType.STOP:
13885 
        break
13886 
      if fid == 0:
13887 
        if ftype == TType.LIST:
13888 
          self.success = []
5411 rajveer 13889 
          (_etype314, _size311) = iprot.readListBegin()
13890 
          for _i315 in xrange(_size311):
13891 
            _elem316 = Order()
13892 
            _elem316.read(iprot)
13893 
            self.success.append(_elem316)
4910 phani.kuma 13894 
          iprot.readListEnd()
13895 
        else:
13896 
          iprot.skip(ftype)
13897 
      else:
13898 
        iprot.skip(ftype)
13899 
      iprot.readFieldEnd()
13900 
    iprot.readStructEnd()
13901 
 
13902 
  def write(self, oprot):
13903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13905 
      return
13906 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13907 
    if self.success is not None:
13908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13910 
      for iter317 in self.success:
13911 
        iter317.write(oprot)
4581 phani.kuma 13912 
      oprot.writeListEnd()
13913 
      oprot.writeFieldEnd()
4910 phani.kuma 13914 
    oprot.writeFieldStop()
13915 
    oprot.writeStructEnd()
13916 
 
13917 
  def validate(self):
13918 
    return
13919 
 
13920 
 
13921 
  def __repr__(self):
13922 
    L = ['%s=%r' % (key, value)
13923 
      for key, value in self.__dict__.iteritems()]
13924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13925 
 
13926 
  def __eq__(self, other):
13927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13928 
 
13929 
  def __ne__(self, other):
13930 
    return not (self == other)
13931 
 
13932 
class markOrdersAsDestinationCityReached_args:
13933 
  """
13934 
  Attributes:
13935 
   - providerId
13936 
   - destination_city_reached_orders
13937 
  """
13938 
 
13939 
  thrift_spec = (
13940 
    None, # 0
13941 
    (1, TType.I64, 'providerId', None, None, ), # 1
13942 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13943 
  )
13944 
 
13945 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13946 
    self.providerId = providerId
13947 
    self.destination_city_reached_orders = destination_city_reached_orders
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 1:
13959 
        if ftype == TType.I64:
13960 
          self.providerId = iprot.readI64();
13961 
        else:
13962 
          iprot.skip(ftype)
13963 
      elif fid == 2:
13964 
        if ftype == TType.MAP:
13965 
          self.destination_city_reached_orders = {}
5411 rajveer 13966 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13967 
          for _i322 in xrange(_size318):
13968 
            _key323 = iprot.readString();
13969 
            _val324 = iprot.readString();
13970 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13971 
          iprot.readMapEnd()
13972 
        else:
13973 
          iprot.skip(ftype)
13974 
      else:
13975 
        iprot.skip(ftype)
13976 
      iprot.readFieldEnd()
13977 
    iprot.readStructEnd()
13978 
 
13979 
  def write(self, oprot):
13980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13982 
      return
13983 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13984 
    if self.providerId is not None:
13985 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13986 
      oprot.writeI64(self.providerId)
13987 
      oprot.writeFieldEnd()
13988 
    if self.destination_city_reached_orders is not None:
13989 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13990 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13991 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13992 
        oprot.writeString(kiter325)
13993 
        oprot.writeString(viter326)
4910 phani.kuma 13994 
      oprot.writeMapEnd()
13995 
      oprot.writeFieldEnd()
13996 
    oprot.writeFieldStop()
13997 
    oprot.writeStructEnd()
13998 
 
13999 
  def validate(self):
14000 
    return
14001 
 
14002 
 
14003 
  def __repr__(self):
14004 
    L = ['%s=%r' % (key, value)
14005 
      for key, value in self.__dict__.iteritems()]
14006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14007 
 
14008 
  def __eq__(self, other):
14009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14010 
 
14011 
  def __ne__(self, other):
14012 
    return not (self == other)
14013 
 
14014 
class markOrdersAsDestinationCityReached_result:
14015 
  """
14016 
  Attributes:
14017 
   - ex
14018 
  """
14019 
 
14020 
  thrift_spec = (
14021 
    None, # 0
14022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14023 
  )
14024 
 
14025 
  def __init__(self, ex=None,):
14026 
    self.ex = ex
14027 
 
14028 
  def read(self, iprot):
14029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14031 
      return
14032 
    iprot.readStructBegin()
14033 
    while True:
14034 
      (fname, ftype, fid) = iprot.readFieldBegin()
14035 
      if ftype == TType.STOP:
14036 
        break
14037 
      if fid == 1:
14038 
        if ftype == TType.STRUCT:
14039 
          self.ex = TransactionServiceException()
14040 
          self.ex.read(iprot)
14041 
        else:
14042 
          iprot.skip(ftype)
14043 
      else:
14044 
        iprot.skip(ftype)
14045 
      iprot.readFieldEnd()
14046 
    iprot.readStructEnd()
14047 
 
14048 
  def write(self, oprot):
14049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14051 
      return
14052 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14053 
    if self.ex is not None:
3064 chandransh 14054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14055 
      self.ex.write(oprot)
1627 ankur.sing 14056 
      oprot.writeFieldEnd()
14057 
    oprot.writeFieldStop()
14058 
    oprot.writeStructEnd()
14059 
 
3431 rajveer 14060 
  def validate(self):
14061 
    return
14062 
 
14063 
 
1627 ankur.sing 14064 
  def __repr__(self):
14065 
    L = ['%s=%r' % (key, value)
14066 
      for key, value in self.__dict__.iteritems()]
14067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14068 
 
14069 
  def __eq__(self, other):
14070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14071 
 
14072 
  def __ne__(self, other):
14073 
    return not (self == other)
14074 
 
4910 phani.kuma 14075 
class markOrdersAsFirstDeliveryAttempted_args:
14076 
  """
14077 
  Attributes:
14078 
   - providerId
14079 
   - first_atdl_orders
14080 
  """
14081 
 
14082 
  thrift_spec = (
14083 
    None, # 0
14084 
    (1, TType.I64, 'providerId', None, None, ), # 1
14085 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14086 
  )
14087 
 
14088 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14089 
    self.providerId = providerId
14090 
    self.first_atdl_orders = first_atdl_orders
14091 
 
14092 
  def read(self, iprot):
14093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14095 
      return
14096 
    iprot.readStructBegin()
14097 
    while True:
14098 
      (fname, ftype, fid) = iprot.readFieldBegin()
14099 
      if ftype == TType.STOP:
14100 
        break
14101 
      if fid == 1:
14102 
        if ftype == TType.I64:
14103 
          self.providerId = iprot.readI64();
14104 
        else:
14105 
          iprot.skip(ftype)
14106 
      elif fid == 2:
14107 
        if ftype == TType.MAP:
14108 
          self.first_atdl_orders = {}
5411 rajveer 14109 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14110 
          for _i331 in xrange(_size327):
14111 
            _key332 = iprot.readString();
14112 
            _val333 = iprot.readString();
14113 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 14114 
          iprot.readMapEnd()
14115 
        else:
14116 
          iprot.skip(ftype)
14117 
      else:
14118 
        iprot.skip(ftype)
14119 
      iprot.readFieldEnd()
14120 
    iprot.readStructEnd()
14121 
 
14122 
  def write(self, oprot):
14123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14125 
      return
14126 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14127 
    if self.providerId is not None:
14128 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14129 
      oprot.writeI64(self.providerId)
14130 
      oprot.writeFieldEnd()
14131 
    if self.first_atdl_orders is not None:
14132 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14133 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 14134 
      for kiter334,viter335 in self.first_atdl_orders.items():
14135 
        oprot.writeString(kiter334)
14136 
        oprot.writeString(viter335)
4910 phani.kuma 14137 
      oprot.writeMapEnd()
14138 
      oprot.writeFieldEnd()
14139 
    oprot.writeFieldStop()
14140 
    oprot.writeStructEnd()
14141 
 
14142 
  def validate(self):
14143 
    return
14144 
 
14145 
 
14146 
  def __repr__(self):
14147 
    L = ['%s=%r' % (key, value)
14148 
      for key, value in self.__dict__.iteritems()]
14149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14150 
 
14151 
  def __eq__(self, other):
14152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14153 
 
14154 
  def __ne__(self, other):
14155 
    return not (self == other)
14156 
 
14157 
class markOrdersAsFirstDeliveryAttempted_result:
14158 
  """
14159 
  Attributes:
14160 
   - ex
14161 
  """
14162 
 
14163 
  thrift_spec = (
14164 
    None, # 0
14165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14166 
  )
14167 
 
14168 
  def __init__(self, ex=None,):
14169 
    self.ex = ex
14170 
 
14171 
  def read(self, iprot):
14172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14174 
      return
14175 
    iprot.readStructBegin()
14176 
    while True:
14177 
      (fname, ftype, fid) = iprot.readFieldBegin()
14178 
      if ftype == TType.STOP:
14179 
        break
14180 
      if fid == 1:
14181 
        if ftype == TType.STRUCT:
14182 
          self.ex = TransactionServiceException()
14183 
          self.ex.read(iprot)
14184 
        else:
14185 
          iprot.skip(ftype)
14186 
      else:
14187 
        iprot.skip(ftype)
14188 
      iprot.readFieldEnd()
14189 
    iprot.readStructEnd()
14190 
 
14191 
  def write(self, oprot):
14192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14194 
      return
14195 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14196 
    if self.ex is not None:
14197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14198 
      self.ex.write(oprot)
14199 
      oprot.writeFieldEnd()
14200 
    oprot.writeFieldStop()
14201 
    oprot.writeStructEnd()
14202 
 
14203 
  def validate(self):
14204 
    return
14205 
 
14206 
 
14207 
  def __repr__(self):
14208 
    L = ['%s=%r' % (key, value)
14209 
      for key, value in self.__dict__.iteritems()]
14210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14211 
 
14212 
  def __eq__(self, other):
14213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14214 
 
14215 
  def __ne__(self, other):
14216 
    return not (self == other)
14217 
 
3064 chandransh 14218 
class getUndeliveredOrders_args:
1886 ankur.sing 14219 
  """
14220 
  Attributes:
3064 chandransh 14221 
   - providerId
14222 
   - warehouseId
1886 ankur.sing 14223 
  """
1627 ankur.sing 14224 
 
1886 ankur.sing 14225 
  thrift_spec = (
14226 
    None, # 0
3064 chandransh 14227 
    (1, TType.I64, 'providerId', None, None, ), # 1
14228 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14229 
  )
14230 
 
3064 chandransh 14231 
  def __init__(self, providerId=None, warehouseId=None,):
14232 
    self.providerId = providerId
14233 
    self.warehouseId = warehouseId
1886 ankur.sing 14234 
 
14235 
  def read(self, iprot):
14236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14238 
      return
14239 
    iprot.readStructBegin()
14240 
    while True:
14241 
      (fname, ftype, fid) = iprot.readFieldBegin()
14242 
      if ftype == TType.STOP:
14243 
        break
14244 
      if fid == 1:
14245 
        if ftype == TType.I64:
3064 chandransh 14246 
          self.providerId = iprot.readI64();
1886 ankur.sing 14247 
        else:
14248 
          iprot.skip(ftype)
3064 chandransh 14249 
      elif fid == 2:
14250 
        if ftype == TType.I64:
14251 
          self.warehouseId = iprot.readI64();
14252 
        else:
14253 
          iprot.skip(ftype)
1886 ankur.sing 14254 
      else:
14255 
        iprot.skip(ftype)
14256 
      iprot.readFieldEnd()
14257 
    iprot.readStructEnd()
14258 
 
14259 
  def write(self, oprot):
14260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14262 
      return
3064 chandransh 14263 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14264 
    if self.providerId is not None:
3064 chandransh 14265 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14266 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14267 
      oprot.writeFieldEnd()
3431 rajveer 14268 
    if self.warehouseId is not None:
3064 chandransh 14269 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14270 
      oprot.writeI64(self.warehouseId)
14271 
      oprot.writeFieldEnd()
1886 ankur.sing 14272 
    oprot.writeFieldStop()
14273 
    oprot.writeStructEnd()
14274 
 
3431 rajveer 14275 
  def validate(self):
14276 
    return
14277 
 
14278 
 
1886 ankur.sing 14279 
  def __repr__(self):
14280 
    L = ['%s=%r' % (key, value)
14281 
      for key, value in self.__dict__.iteritems()]
14282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14283 
 
14284 
  def __eq__(self, other):
14285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14286 
 
14287 
  def __ne__(self, other):
14288 
    return not (self == other)
14289 
 
3064 chandransh 14290 
class getUndeliveredOrders_result:
1886 ankur.sing 14291 
  """
14292 
  Attributes:
14293 
   - success
14294 
  """
14295 
 
14296 
  thrift_spec = (
14297 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14298 
  )
14299 
 
14300 
  def __init__(self, success=None,):
14301 
    self.success = success
14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 0:
14313 
        if ftype == TType.LIST:
14314 
          self.success = []
5411 rajveer 14315 
          (_etype339, _size336) = iprot.readListBegin()
14316 
          for _i340 in xrange(_size336):
14317 
            _elem341 = Order()
14318 
            _elem341.read(iprot)
14319 
            self.success.append(_elem341)
1886 ankur.sing 14320 
          iprot.readListEnd()
14321 
        else:
14322 
          iprot.skip(ftype)
14323 
      else:
14324 
        iprot.skip(ftype)
14325 
      iprot.readFieldEnd()
14326 
    iprot.readStructEnd()
14327 
 
14328 
  def write(self, oprot):
14329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14331 
      return
3064 chandransh 14332 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14333 
    if self.success is not None:
1886 ankur.sing 14334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14336 
      for iter342 in self.success:
14337 
        iter342.write(oprot)
1886 ankur.sing 14338 
      oprot.writeListEnd()
14339 
      oprot.writeFieldEnd()
14340 
    oprot.writeFieldStop()
14341 
    oprot.writeStructEnd()
14342 
 
3431 rajveer 14343 
  def validate(self):
14344 
    return
14345 
 
14346 
 
1886 ankur.sing 14347 
  def __repr__(self):
14348 
    L = ['%s=%r' % (key, value)
14349 
      for key, value in self.__dict__.iteritems()]
14350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14351 
 
14352 
  def __eq__(self, other):
14353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14354 
 
14355 
  def __ne__(self, other):
14356 
    return not (self == other)
14357 
 
4783 phani.kuma 14358 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14359 
 
14360 
  thrift_spec = (
14361 
  )
14362 
 
14363 
  def read(self, iprot):
14364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14366 
      return
14367 
    iprot.readStructBegin()
14368 
    while True:
14369 
      (fname, ftype, fid) = iprot.readFieldBegin()
14370 
      if ftype == TType.STOP:
14371 
        break
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('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14382 
    oprot.writeFieldStop()
14383 
    oprot.writeStructEnd()
14384 
 
14385 
  def validate(self):
14386 
    return
14387 
 
14388 
 
14389 
  def __repr__(self):
14390 
    L = ['%s=%r' % (key, value)
14391 
      for key, value in self.__dict__.iteritems()]
14392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14393 
 
14394 
  def __eq__(self, other):
14395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14396 
 
14397 
  def __ne__(self, other):
14398 
    return not (self == other)
14399 
 
14400 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14401 
  """
14402 
  Attributes:
14403 
   - success
14404 
  """
14405 
 
14406 
  thrift_spec = (
14407 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14408 
  )
14409 
 
14410 
  def __init__(self, success=None,):
14411 
    self.success = success
14412 
 
14413 
  def read(self, iprot):
14414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14416 
      return
14417 
    iprot.readStructBegin()
14418 
    while True:
14419 
      (fname, ftype, fid) = iprot.readFieldBegin()
14420 
      if ftype == TType.STOP:
14421 
        break
14422 
      if fid == 0:
14423 
        if ftype == TType.LIST:
14424 
          self.success = []
5411 rajveer 14425 
          (_etype346, _size343) = iprot.readListBegin()
14426 
          for _i347 in xrange(_size343):
14427 
            _elem348 = Order()
14428 
            _elem348.read(iprot)
14429 
            self.success.append(_elem348)
4783 phani.kuma 14430 
          iprot.readListEnd()
14431 
        else:
14432 
          iprot.skip(ftype)
14433 
      else:
14434 
        iprot.skip(ftype)
14435 
      iprot.readFieldEnd()
14436 
    iprot.readStructEnd()
14437 
 
14438 
  def write(self, oprot):
14439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14441 
      return
14442 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14443 
    if self.success is not None:
14444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14445 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14446 
      for iter349 in self.success:
14447 
        iter349.write(oprot)
4783 phani.kuma 14448 
      oprot.writeListEnd()
14449 
      oprot.writeFieldEnd()
14450 
    oprot.writeFieldStop()
14451 
    oprot.writeStructEnd()
14452 
 
14453 
  def validate(self):
14454 
    return
14455 
 
14456 
 
14457 
  def __repr__(self):
14458 
    L = ['%s=%r' % (key, value)
14459 
      for key, value in self.__dict__.iteritems()]
14460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14461 
 
14462 
  def __eq__(self, other):
14463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14464 
 
14465 
  def __ne__(self, other):
14466 
    return not (self == other)
14467 
 
2536 chandransh 14468 
class toggleDOAFlag_args:
14469 
  """
14470 
  Attributes:
14471 
   - orderId
14472 
  """
1886 ankur.sing 14473 
 
2536 chandransh 14474 
  thrift_spec = (
14475 
    None, # 0
14476 
    (1, TType.I64, 'orderId', None, None, ), # 1
14477 
  )
14478 
 
14479 
  def __init__(self, orderId=None,):
14480 
    self.orderId = orderId
14481 
 
14482 
  def read(self, iprot):
14483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14485 
      return
14486 
    iprot.readStructBegin()
14487 
    while True:
14488 
      (fname, ftype, fid) = iprot.readFieldBegin()
14489 
      if ftype == TType.STOP:
14490 
        break
14491 
      if fid == 1:
14492 
        if ftype == TType.I64:
14493 
          self.orderId = iprot.readI64();
14494 
        else:
14495 
          iprot.skip(ftype)
14496 
      else:
14497 
        iprot.skip(ftype)
14498 
      iprot.readFieldEnd()
14499 
    iprot.readStructEnd()
14500 
 
14501 
  def write(self, oprot):
14502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14504 
      return
14505 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14506 
    if self.orderId is not None:
2536 chandransh 14507 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14508 
      oprot.writeI64(self.orderId)
14509 
      oprot.writeFieldEnd()
14510 
    oprot.writeFieldStop()
14511 
    oprot.writeStructEnd()
14512 
 
3431 rajveer 14513 
  def validate(self):
14514 
    return
14515 
 
14516 
 
2536 chandransh 14517 
  def __repr__(self):
14518 
    L = ['%s=%r' % (key, value)
14519 
      for key, value in self.__dict__.iteritems()]
14520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14521 
 
14522 
  def __eq__(self, other):
14523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14524 
 
14525 
  def __ne__(self, other):
14526 
    return not (self == other)
14527 
 
14528 
class toggleDOAFlag_result:
14529 
  """
14530 
  Attributes:
14531 
   - success
14532 
   - ex
14533 
  """
14534 
 
14535 
  thrift_spec = (
14536 
    (0, TType.BOOL, 'success', None, None, ), # 0
14537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14538 
  )
14539 
 
14540 
  def __init__(self, success=None, ex=None,):
14541 
    self.success = success
14542 
    self.ex = ex
14543 
 
14544 
  def read(self, iprot):
14545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14547 
      return
14548 
    iprot.readStructBegin()
14549 
    while True:
14550 
      (fname, ftype, fid) = iprot.readFieldBegin()
14551 
      if ftype == TType.STOP:
14552 
        break
14553 
      if fid == 0:
14554 
        if ftype == TType.BOOL:
14555 
          self.success = iprot.readBool();
14556 
        else:
14557 
          iprot.skip(ftype)
14558 
      elif fid == 1:
14559 
        if ftype == TType.STRUCT:
14560 
          self.ex = TransactionServiceException()
14561 
          self.ex.read(iprot)
14562 
        else:
14563 
          iprot.skip(ftype)
14564 
      else:
14565 
        iprot.skip(ftype)
14566 
      iprot.readFieldEnd()
14567 
    iprot.readStructEnd()
14568 
 
14569 
  def write(self, oprot):
14570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14572 
      return
14573 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14574 
    if self.success is not None:
2536 chandransh 14575 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14576 
      oprot.writeBool(self.success)
14577 
      oprot.writeFieldEnd()
3431 rajveer 14578 
    if self.ex is not None:
2536 chandransh 14579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14580 
      self.ex.write(oprot)
14581 
      oprot.writeFieldEnd()
14582 
    oprot.writeFieldStop()
14583 
    oprot.writeStructEnd()
14584 
 
3431 rajveer 14585 
  def validate(self):
14586 
    return
14587 
 
14588 
 
2536 chandransh 14589 
  def __repr__(self):
14590 
    L = ['%s=%r' % (key, value)
14591 
      for key, value in self.__dict__.iteritems()]
14592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14593 
 
14594 
  def __eq__(self, other):
14595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14596 
 
14597 
  def __ne__(self, other):
14598 
    return not (self == other)
14599 
 
4712 rajveer 14600 
class markOrderAsDelivered_args:
14601 
  """
14602 
  Attributes:
14603 
   - orderId
14604 
   - deliveryTimestamp
14605 
   - receiver
14606 
  """
14607 
 
14608 
  thrift_spec = None
14609 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14610 
    self.orderId = orderId
14611 
    self.deliveryTimestamp = deliveryTimestamp
14612 
    self.receiver = receiver
14613 
 
14614 
  def read(self, iprot):
14615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14617 
      return
14618 
    iprot.readStructBegin()
14619 
    while True:
14620 
      (fname, ftype, fid) = iprot.readFieldBegin()
14621 
      if ftype == TType.STOP:
14622 
        break
14623 
      if fid == 1:
14624 
        if ftype == TType.I64:
14625 
          self.orderId = iprot.readI64();
14626 
        else:
14627 
          iprot.skip(ftype)
14628 
      elif fid == 2:
14629 
        if ftype == TType.I64:
14630 
          self.deliveryTimestamp = iprot.readI64();
14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      elif fid == -1:
14634 
        if ftype == TType.STRING:
14635 
          self.receiver = iprot.readString();
14636 
        else:
14637 
          iprot.skip(ftype)
14638 
      else:
14639 
        iprot.skip(ftype)
14640 
      iprot.readFieldEnd()
14641 
    iprot.readStructEnd()
14642 
 
14643 
  def write(self, oprot):
14644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14646 
      return
14647 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14648 
    if self.receiver is not None:
14649 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14650 
      oprot.writeString(self.receiver)
14651 
      oprot.writeFieldEnd()
14652 
    if self.orderId is not None:
14653 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14654 
      oprot.writeI64(self.orderId)
14655 
      oprot.writeFieldEnd()
14656 
    if self.deliveryTimestamp is not None:
14657 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14658 
      oprot.writeI64(self.deliveryTimestamp)
14659 
      oprot.writeFieldEnd()
14660 
    oprot.writeFieldStop()
14661 
    oprot.writeStructEnd()
14662 
 
14663 
  def validate(self):
14664 
    return
14665 
 
14666 
 
14667 
  def __repr__(self):
14668 
    L = ['%s=%r' % (key, value)
14669 
      for key, value in self.__dict__.iteritems()]
14670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14671 
 
14672 
  def __eq__(self, other):
14673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14674 
 
14675 
  def __ne__(self, other):
14676 
    return not (self == other)
14677 
 
14678 
class markOrderAsDelivered_result:
14679 
  """
14680 
  Attributes:
14681 
   - ex
14682 
  """
14683 
 
14684 
  thrift_spec = (
14685 
    None, # 0
14686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14687 
  )
14688 
 
14689 
  def __init__(self, ex=None,):
14690 
    self.ex = ex
14691 
 
14692 
  def read(self, iprot):
14693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14695 
      return
14696 
    iprot.readStructBegin()
14697 
    while True:
14698 
      (fname, ftype, fid) = iprot.readFieldBegin()
14699 
      if ftype == TType.STOP:
14700 
        break
14701 
      if fid == 1:
14702 
        if ftype == TType.STRUCT:
14703 
          self.ex = TransactionServiceException()
14704 
          self.ex.read(iprot)
14705 
        else:
14706 
          iprot.skip(ftype)
14707 
      else:
14708 
        iprot.skip(ftype)
14709 
      iprot.readFieldEnd()
14710 
    iprot.readStructEnd()
14711 
 
14712 
  def write(self, oprot):
14713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14715 
      return
14716 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14717 
    if self.ex is not None:
14718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14719 
      self.ex.write(oprot)
14720 
      oprot.writeFieldEnd()
14721 
    oprot.writeFieldStop()
14722 
    oprot.writeStructEnd()
14723 
 
14724 
  def validate(self):
14725 
    return
14726 
 
14727 
 
14728 
  def __repr__(self):
14729 
    L = ['%s=%r' % (key, value)
14730 
      for key, value in self.__dict__.iteritems()]
14731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14732 
 
14733 
  def __eq__(self, other):
14734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14735 
 
14736 
  def __ne__(self, other):
14737 
    return not (self == other)
14738 
 
5553 rajveer 14739 
class markOrderAsReceivedAtStore_args:
14740 
  """
14741 
  Attributes:
14742 
   - orderId
14743 
   - deliveryTimestamp
14744 
  """
14745 
 
14746 
  thrift_spec = (
14747 
    None, # 0
14748 
    (1, TType.I64, 'orderId', None, None, ), # 1
14749 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
14750 
  )
14751 
 
14752 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
14753 
    self.orderId = orderId
14754 
    self.deliveryTimestamp = deliveryTimestamp
14755 
 
14756 
  def read(self, iprot):
14757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14759 
      return
14760 
    iprot.readStructBegin()
14761 
    while True:
14762 
      (fname, ftype, fid) = iprot.readFieldBegin()
14763 
      if ftype == TType.STOP:
14764 
        break
14765 
      if fid == 1:
14766 
        if ftype == TType.I64:
14767 
          self.orderId = iprot.readI64();
14768 
        else:
14769 
          iprot.skip(ftype)
14770 
      elif fid == 2:
14771 
        if ftype == TType.I64:
14772 
          self.deliveryTimestamp = iprot.readI64();
14773 
        else:
14774 
          iprot.skip(ftype)
14775 
      else:
14776 
        iprot.skip(ftype)
14777 
      iprot.readFieldEnd()
14778 
    iprot.readStructEnd()
14779 
 
14780 
  def write(self, oprot):
14781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14783 
      return
14784 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
14785 
    if self.orderId is not None:
14786 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14787 
      oprot.writeI64(self.orderId)
14788 
      oprot.writeFieldEnd()
14789 
    if self.deliveryTimestamp is not None:
14790 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14791 
      oprot.writeI64(self.deliveryTimestamp)
14792 
      oprot.writeFieldEnd()
14793 
    oprot.writeFieldStop()
14794 
    oprot.writeStructEnd()
14795 
 
14796 
  def validate(self):
14797 
    return
14798 
 
14799 
 
14800 
  def __repr__(self):
14801 
    L = ['%s=%r' % (key, value)
14802 
      for key, value in self.__dict__.iteritems()]
14803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14804 
 
14805 
  def __eq__(self, other):
14806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14807 
 
14808 
  def __ne__(self, other):
14809 
    return not (self == other)
14810 
 
14811 
class markOrderAsReceivedAtStore_result:
14812 
  """
14813 
  Attributes:
14814 
   - ex
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    None, # 0
14819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14820 
  )
14821 
 
14822 
  def __init__(self, ex=None,):
14823 
    self.ex = ex
14824 
 
14825 
  def read(self, iprot):
14826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14828 
      return
14829 
    iprot.readStructBegin()
14830 
    while True:
14831 
      (fname, ftype, fid) = iprot.readFieldBegin()
14832 
      if ftype == TType.STOP:
14833 
        break
14834 
      if fid == 1:
14835 
        if ftype == TType.STRUCT:
14836 
          self.ex = TransactionServiceException()
14837 
          self.ex.read(iprot)
14838 
        else:
14839 
          iprot.skip(ftype)
14840 
      else:
14841 
        iprot.skip(ftype)
14842 
      iprot.readFieldEnd()
14843 
    iprot.readStructEnd()
14844 
 
14845 
  def write(self, oprot):
14846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14848 
      return
14849 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
14850 
    if self.ex is not None:
14851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14852 
      self.ex.write(oprot)
14853 
      oprot.writeFieldEnd()
14854 
    oprot.writeFieldStop()
14855 
    oprot.writeStructEnd()
14856 
 
14857 
  def validate(self):
14858 
    return
14859 
 
14860 
 
14861 
  def __repr__(self):
14862 
    L = ['%s=%r' % (key, value)
14863 
      for key, value in self.__dict__.iteritems()]
14864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14865 
 
14866 
  def __eq__(self, other):
14867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14868 
 
14869 
  def __ne__(self, other):
14870 
    return not (self == other)
14871 
 
4454 rajveer 14872 
class markOrderDoaRequestReceived_args:
14873 
  """
14874 
  Attributes:
14875 
   - orderId
14876 
  """
14877 
 
14878 
  thrift_spec = (
14879 
    None, # 0
14880 
    (1, TType.I64, 'orderId', None, None, ), # 1
14881 
  )
14882 
 
14883 
  def __init__(self, orderId=None,):
14884 
    self.orderId = orderId
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      if fid == 1:
14896 
        if ftype == TType.I64:
14897 
          self.orderId = iprot.readI64();
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      else:
14901 
        iprot.skip(ftype)
14902 
      iprot.readFieldEnd()
14903 
    iprot.readStructEnd()
14904 
 
14905 
  def write(self, oprot):
14906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14908 
      return
14909 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14910 
    if self.orderId is not None:
14911 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14912 
      oprot.writeI64(self.orderId)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
14931 
 
14932 
class markOrderDoaRequestReceived_result:
14933 
  """
14934 
  Attributes:
14935 
   - success
14936 
   - ex
14937 
  """
14938 
 
14939 
  thrift_spec = (
14940 
    (0, TType.BOOL, 'success', None, None, ), # 0
14941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14942 
  )
14943 
 
14944 
  def __init__(self, success=None, ex=None,):
14945 
    self.success = success
14946 
    self.ex = ex
14947 
 
14948 
  def read(self, iprot):
14949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14951 
      return
14952 
    iprot.readStructBegin()
14953 
    while True:
14954 
      (fname, ftype, fid) = iprot.readFieldBegin()
14955 
      if ftype == TType.STOP:
14956 
        break
14957 
      if fid == 0:
14958 
        if ftype == TType.BOOL:
14959 
          self.success = iprot.readBool();
14960 
        else:
14961 
          iprot.skip(ftype)
14962 
      elif fid == 1:
14963 
        if ftype == TType.STRUCT:
14964 
          self.ex = TransactionServiceException()
14965 
          self.ex.read(iprot)
14966 
        else:
14967 
          iprot.skip(ftype)
14968 
      else:
14969 
        iprot.skip(ftype)
14970 
      iprot.readFieldEnd()
14971 
    iprot.readStructEnd()
14972 
 
14973 
  def write(self, oprot):
14974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14976 
      return
14977 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14978 
    if self.success is not None:
14979 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14980 
      oprot.writeBool(self.success)
14981 
      oprot.writeFieldEnd()
14982 
    if self.ex is not None:
14983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14984 
      self.ex.write(oprot)
14985 
      oprot.writeFieldEnd()
14986 
    oprot.writeFieldStop()
14987 
    oprot.writeStructEnd()
14988 
 
14989 
  def validate(self):
14990 
    return
14991 
 
14992 
 
14993 
  def __repr__(self):
14994 
    L = ['%s=%r' % (key, value)
14995 
      for key, value in self.__dict__.iteritems()]
14996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14997 
 
14998 
  def __eq__(self, other):
14999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15000 
 
15001 
  def __ne__(self, other):
15002 
    return not (self == other)
15003 
 
15004 
class markOrderDoaRequestAuthorized_args:
15005 
  """
15006 
  Attributes:
15007 
   - orderId
15008 
   - isAuthorized
15009 
  """
15010 
 
15011 
  thrift_spec = (
15012 
    None, # 0
15013 
    (1, TType.I64, 'orderId', None, None, ), # 1
15014 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15015 
  )
15016 
 
15017 
  def __init__(self, orderId=None, isAuthorized=None,):
15018 
    self.orderId = orderId
15019 
    self.isAuthorized = isAuthorized
15020 
 
15021 
  def read(self, iprot):
15022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15024 
      return
15025 
    iprot.readStructBegin()
15026 
    while True:
15027 
      (fname, ftype, fid) = iprot.readFieldBegin()
15028 
      if ftype == TType.STOP:
15029 
        break
15030 
      if fid == 1:
15031 
        if ftype == TType.I64:
15032 
          self.orderId = iprot.readI64();
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      elif fid == 2:
15036 
        if ftype == TType.BOOL:
15037 
          self.isAuthorized = iprot.readBool();
15038 
        else:
15039 
          iprot.skip(ftype)
15040 
      else:
15041 
        iprot.skip(ftype)
15042 
      iprot.readFieldEnd()
15043 
    iprot.readStructEnd()
15044 
 
15045 
  def write(self, oprot):
15046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15048 
      return
15049 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15050 
    if self.orderId is not None:
15051 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15052 
      oprot.writeI64(self.orderId)
15053 
      oprot.writeFieldEnd()
15054 
    if self.isAuthorized is not None:
15055 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15056 
      oprot.writeBool(self.isAuthorized)
15057 
      oprot.writeFieldEnd()
15058 
    oprot.writeFieldStop()
15059 
    oprot.writeStructEnd()
15060 
 
15061 
  def validate(self):
15062 
    return
15063 
 
15064 
 
15065 
  def __repr__(self):
15066 
    L = ['%s=%r' % (key, value)
15067 
      for key, value in self.__dict__.iteritems()]
15068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15069 
 
15070 
  def __eq__(self, other):
15071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15072 
 
15073 
  def __ne__(self, other):
15074 
    return not (self == other)
15075 
 
15076 
class markOrderDoaRequestAuthorized_result:
15077 
  """
15078 
  Attributes:
15079 
   - success
15080 
   - ex
15081 
  """
15082 
 
15083 
  thrift_spec = (
15084 
    (0, TType.BOOL, 'success', None, None, ), # 0
15085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15086 
  )
15087 
 
15088 
  def __init__(self, success=None, ex=None,):
15089 
    self.success = success
15090 
    self.ex = ex
15091 
 
15092 
  def read(self, iprot):
15093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15095 
      return
15096 
    iprot.readStructBegin()
15097 
    while True:
15098 
      (fname, ftype, fid) = iprot.readFieldBegin()
15099 
      if ftype == TType.STOP:
15100 
        break
15101 
      if fid == 0:
15102 
        if ftype == TType.BOOL:
15103 
          self.success = iprot.readBool();
15104 
        else:
15105 
          iprot.skip(ftype)
15106 
      elif fid == 1:
15107 
        if ftype == TType.STRUCT:
15108 
          self.ex = TransactionServiceException()
15109 
          self.ex.read(iprot)
15110 
        else:
15111 
          iprot.skip(ftype)
15112 
      else:
15113 
        iprot.skip(ftype)
15114 
      iprot.readFieldEnd()
15115 
    iprot.readStructEnd()
15116 
 
15117 
  def write(self, oprot):
15118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15120 
      return
15121 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15122 
    if self.success is not None:
15123 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15124 
      oprot.writeBool(self.success)
15125 
      oprot.writeFieldEnd()
15126 
    if self.ex is not None:
15127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15128 
      self.ex.write(oprot)
15129 
      oprot.writeFieldEnd()
15130 
    oprot.writeFieldStop()
15131 
    oprot.writeStructEnd()
15132 
 
15133 
  def validate(self):
15134 
    return
15135 
 
15136 
 
15137 
  def __repr__(self):
15138 
    L = ['%s=%r' % (key, value)
15139 
      for key, value in self.__dict__.iteritems()]
15140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15141 
 
15142 
  def __eq__(self, other):
15143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15144 
 
15145 
  def __ne__(self, other):
15146 
    return not (self == other)
15147 
 
4488 rajveer 15148 
class markOrderReturnRequestReceived_args:
15149 
  """
15150 
  Attributes:
15151 
   - orderId
15152 
  """
15153 
 
15154 
  thrift_spec = (
15155 
    None, # 0
15156 
    (1, TType.I64, 'orderId', None, None, ), # 1
15157 
  )
15158 
 
15159 
  def __init__(self, orderId=None,):
15160 
    self.orderId = orderId
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 1:
15172 
        if ftype == TType.I64:
15173 
          self.orderId = iprot.readI64();
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      else:
15177 
        iprot.skip(ftype)
15178 
      iprot.readFieldEnd()
15179 
    iprot.readStructEnd()
15180 
 
15181 
  def write(self, oprot):
15182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15184 
      return
15185 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15186 
    if self.orderId is not None:
15187 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15188 
      oprot.writeI64(self.orderId)
15189 
      oprot.writeFieldEnd()
15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
15207 
 
15208 
class markOrderReturnRequestReceived_result:
15209 
  """
15210 
  Attributes:
15211 
   - success
15212 
   - ex
15213 
  """
15214 
 
15215 
  thrift_spec = (
15216 
    (0, TType.BOOL, 'success', None, None, ), # 0
15217 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15218 
  )
15219 
 
15220 
  def __init__(self, success=None, ex=None,):
15221 
    self.success = success
15222 
    self.ex = ex
15223 
 
15224 
  def read(self, iprot):
15225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15227 
      return
15228 
    iprot.readStructBegin()
15229 
    while True:
15230 
      (fname, ftype, fid) = iprot.readFieldBegin()
15231 
      if ftype == TType.STOP:
15232 
        break
15233 
      if fid == 0:
15234 
        if ftype == TType.BOOL:
15235 
          self.success = iprot.readBool();
15236 
        else:
15237 
          iprot.skip(ftype)
15238 
      elif fid == 1:
15239 
        if ftype == TType.STRUCT:
15240 
          self.ex = TransactionServiceException()
15241 
          self.ex.read(iprot)
15242 
        else:
15243 
          iprot.skip(ftype)
15244 
      else:
15245 
        iprot.skip(ftype)
15246 
      iprot.readFieldEnd()
15247 
    iprot.readStructEnd()
15248 
 
15249 
  def write(self, oprot):
15250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15252 
      return
15253 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15254 
    if self.success is not None:
15255 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15256 
      oprot.writeBool(self.success)
15257 
      oprot.writeFieldEnd()
15258 
    if self.ex is not None:
15259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15260 
      self.ex.write(oprot)
15261 
      oprot.writeFieldEnd()
15262 
    oprot.writeFieldStop()
15263 
    oprot.writeStructEnd()
15264 
 
15265 
  def validate(self):
15266 
    return
15267 
 
15268 
 
15269 
  def __repr__(self):
15270 
    L = ['%s=%r' % (key, value)
15271 
      for key, value in self.__dict__.iteritems()]
15272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15273 
 
15274 
  def __eq__(self, other):
15275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15276 
 
15277 
  def __ne__(self, other):
15278 
    return not (self == other)
15279 
 
15280 
class markOrderReturnRequestAuthorized_args:
15281 
  """
15282 
  Attributes:
15283 
   - orderId
15284 
   - isAuthorized
15285 
  """
15286 
 
15287 
  thrift_spec = (
15288 
    None, # 0
15289 
    (1, TType.I64, 'orderId', None, None, ), # 1
15290 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15291 
  )
15292 
 
15293 
  def __init__(self, orderId=None, isAuthorized=None,):
15294 
    self.orderId = orderId
15295 
    self.isAuthorized = isAuthorized
15296 
 
15297 
  def read(self, iprot):
15298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15300 
      return
15301 
    iprot.readStructBegin()
15302 
    while True:
15303 
      (fname, ftype, fid) = iprot.readFieldBegin()
15304 
      if ftype == TType.STOP:
15305 
        break
15306 
      if fid == 1:
15307 
        if ftype == TType.I64:
15308 
          self.orderId = iprot.readI64();
15309 
        else:
15310 
          iprot.skip(ftype)
15311 
      elif fid == 2:
15312 
        if ftype == TType.BOOL:
15313 
          self.isAuthorized = iprot.readBool();
15314 
        else:
15315 
          iprot.skip(ftype)
15316 
      else:
15317 
        iprot.skip(ftype)
15318 
      iprot.readFieldEnd()
15319 
    iprot.readStructEnd()
15320 
 
15321 
  def write(self, oprot):
15322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15324 
      return
15325 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15326 
    if self.orderId is not None:
15327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15328 
      oprot.writeI64(self.orderId)
15329 
      oprot.writeFieldEnd()
15330 
    if self.isAuthorized is not None:
15331 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15332 
      oprot.writeBool(self.isAuthorized)
15333 
      oprot.writeFieldEnd()
15334 
    oprot.writeFieldStop()
15335 
    oprot.writeStructEnd()
15336 
 
15337 
  def validate(self):
15338 
    return
15339 
 
15340 
 
15341 
  def __repr__(self):
15342 
    L = ['%s=%r' % (key, value)
15343 
      for key, value in self.__dict__.iteritems()]
15344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15345 
 
15346 
  def __eq__(self, other):
15347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15348 
 
15349 
  def __ne__(self, other):
15350 
    return not (self == other)
15351 
 
15352 
class markOrderReturnRequestAuthorized_result:
15353 
  """
15354 
  Attributes:
15355 
   - success
15356 
   - ex
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    (0, TType.BOOL, 'success', None, None, ), # 0
15361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15362 
  )
15363 
 
15364 
  def __init__(self, success=None, ex=None,):
15365 
    self.success = success
15366 
    self.ex = ex
15367 
 
15368 
  def read(self, iprot):
15369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15371 
      return
15372 
    iprot.readStructBegin()
15373 
    while True:
15374 
      (fname, ftype, fid) = iprot.readFieldBegin()
15375 
      if ftype == TType.STOP:
15376 
        break
15377 
      if fid == 0:
15378 
        if ftype == TType.BOOL:
15379 
          self.success = iprot.readBool();
15380 
        else:
15381 
          iprot.skip(ftype)
15382 
      elif fid == 1:
15383 
        if ftype == TType.STRUCT:
15384 
          self.ex = TransactionServiceException()
15385 
          self.ex.read(iprot)
15386 
        else:
15387 
          iprot.skip(ftype)
15388 
      else:
15389 
        iprot.skip(ftype)
15390 
      iprot.readFieldEnd()
15391 
    iprot.readStructEnd()
15392 
 
15393 
  def write(self, oprot):
15394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15396 
      return
15397 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15398 
    if self.success is not None:
15399 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15400 
      oprot.writeBool(self.success)
15401 
      oprot.writeFieldEnd()
15402 
    if self.ex is not None:
15403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15404 
      self.ex.write(oprot)
15405 
      oprot.writeFieldEnd()
15406 
    oprot.writeFieldStop()
15407 
    oprot.writeStructEnd()
15408 
 
15409 
  def validate(self):
15410 
    return
15411 
 
15412 
 
15413 
  def __repr__(self):
15414 
    L = ['%s=%r' % (key, value)
15415 
      for key, value in self.__dict__.iteritems()]
15416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15417 
 
15418 
  def __eq__(self, other):
15419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15420 
 
15421 
  def __ne__(self, other):
15422 
    return not (self == other)
15423 
 
2536 chandransh 15424 
class requestPickupNumber_args:
15425 
  """
15426 
  Attributes:
15427 
   - orderId
4579 rajveer 15428 
   - providerId
2536 chandransh 15429 
  """
15430 
 
15431 
  thrift_spec = (
15432 
    None, # 0
15433 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15434 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15435 
  )
15436 
 
4579 rajveer 15437 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15438 
    self.orderId = orderId
4579 rajveer 15439 
    self.providerId = providerId
2536 chandransh 15440 
 
15441 
  def read(self, iprot):
15442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15444 
      return
15445 
    iprot.readStructBegin()
15446 
    while True:
15447 
      (fname, ftype, fid) = iprot.readFieldBegin()
15448 
      if ftype == TType.STOP:
15449 
        break
15450 
      if fid == 1:
15451 
        if ftype == TType.I64:
15452 
          self.orderId = iprot.readI64();
15453 
        else:
15454 
          iprot.skip(ftype)
4579 rajveer 15455 
      elif fid == 2:
15456 
        if ftype == TType.I64:
15457 
          self.providerId = iprot.readI64();
15458 
        else:
15459 
          iprot.skip(ftype)
2536 chandransh 15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15470 
    if self.orderId is not None:
2536 chandransh 15471 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15472 
      oprot.writeI64(self.orderId)
15473 
      oprot.writeFieldEnd()
4579 rajveer 15474 
    if self.providerId is not None:
15475 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15476 
      oprot.writeI64(self.providerId)
15477 
      oprot.writeFieldEnd()
2536 chandransh 15478 
    oprot.writeFieldStop()
15479 
    oprot.writeStructEnd()
15480 
 
3431 rajveer 15481 
  def validate(self):
15482 
    return
15483 
 
15484 
 
2536 chandransh 15485 
  def __repr__(self):
15486 
    L = ['%s=%r' % (key, value)
15487 
      for key, value in self.__dict__.iteritems()]
15488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15489 
 
15490 
  def __eq__(self, other):
15491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15492 
 
15493 
  def __ne__(self, other):
15494 
    return not (self == other)
15495 
 
15496 
class requestPickupNumber_result:
15497 
  """
15498 
  Attributes:
15499 
   - success
15500 
   - ex
15501 
  """
15502 
 
15503 
  thrift_spec = (
15504 
    (0, TType.BOOL, 'success', None, None, ), # 0
15505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15506 
  )
15507 
 
15508 
  def __init__(self, success=None, ex=None,):
15509 
    self.success = success
15510 
    self.ex = ex
15511 
 
15512 
  def read(self, iprot):
15513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15515 
      return
15516 
    iprot.readStructBegin()
15517 
    while True:
15518 
      (fname, ftype, fid) = iprot.readFieldBegin()
15519 
      if ftype == TType.STOP:
15520 
        break
15521 
      if fid == 0:
15522 
        if ftype == TType.BOOL:
15523 
          self.success = iprot.readBool();
15524 
        else:
15525 
          iprot.skip(ftype)
15526 
      elif fid == 1:
15527 
        if ftype == TType.STRUCT:
15528 
          self.ex = TransactionServiceException()
15529 
          self.ex.read(iprot)
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('requestPickupNumber_result')
3431 rajveer 15542 
    if self.success is not None:
2536 chandransh 15543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15544 
      oprot.writeBool(self.success)
15545 
      oprot.writeFieldEnd()
3431 rajveer 15546 
    if self.ex is not None:
2536 chandransh 15547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15548 
      self.ex.write(oprot)
15549 
      oprot.writeFieldEnd()
15550 
    oprot.writeFieldStop()
15551 
    oprot.writeStructEnd()
15552 
 
3431 rajveer 15553 
  def validate(self):
15554 
    return
15555 
 
15556 
 
2536 chandransh 15557 
  def __repr__(self):
15558 
    L = ['%s=%r' % (key, value)
15559 
      for key, value in self.__dict__.iteritems()]
15560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15561 
 
15562 
  def __eq__(self, other):
15563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15564 
 
15565 
  def __ne__(self, other):
15566 
    return not (self == other)
15567 
 
15568 
class authorizePickup_args:
15569 
  """
15570 
  Attributes:
15571 
   - orderId
15572 
   - pickupNumber
4602 rajveer 15573 
   - providerId
2536 chandransh 15574 
  """
15575 
 
15576 
  thrift_spec = (
15577 
    None, # 0
15578 
    (1, TType.I64, 'orderId', None, None, ), # 1
15579 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15580 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15581 
  )
15582 
 
4602 rajveer 15583 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15584 
    self.orderId = orderId
15585 
    self.pickupNumber = pickupNumber
4602 rajveer 15586 
    self.providerId = providerId
2536 chandransh 15587 
 
15588 
  def read(self, iprot):
15589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15591 
      return
15592 
    iprot.readStructBegin()
15593 
    while True:
15594 
      (fname, ftype, fid) = iprot.readFieldBegin()
15595 
      if ftype == TType.STOP:
15596 
        break
15597 
      if fid == 1:
15598 
        if ftype == TType.I64:
15599 
          self.orderId = iprot.readI64();
15600 
        else:
15601 
          iprot.skip(ftype)
15602 
      elif fid == 2:
15603 
        if ftype == TType.STRING:
15604 
          self.pickupNumber = iprot.readString();
15605 
        else:
15606 
          iprot.skip(ftype)
4602 rajveer 15607 
      elif fid == 3:
15608 
        if ftype == TType.I64:
15609 
          self.providerId = iprot.readI64();
15610 
        else:
15611 
          iprot.skip(ftype)
2536 chandransh 15612 
      else:
15613 
        iprot.skip(ftype)
15614 
      iprot.readFieldEnd()
15615 
    iprot.readStructEnd()
15616 
 
15617 
  def write(self, oprot):
15618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15620 
      return
15621 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15622 
    if self.orderId is not None:
2536 chandransh 15623 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15624 
      oprot.writeI64(self.orderId)
15625 
      oprot.writeFieldEnd()
3431 rajveer 15626 
    if self.pickupNumber is not None:
2536 chandransh 15627 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15628 
      oprot.writeString(self.pickupNumber)
15629 
      oprot.writeFieldEnd()
4602 rajveer 15630 
    if self.providerId is not None:
15631 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15632 
      oprot.writeI64(self.providerId)
15633 
      oprot.writeFieldEnd()
2536 chandransh 15634 
    oprot.writeFieldStop()
15635 
    oprot.writeStructEnd()
15636 
 
3431 rajveer 15637 
  def validate(self):
15638 
    return
15639 
 
15640 
 
2536 chandransh 15641 
  def __repr__(self):
15642 
    L = ['%s=%r' % (key, value)
15643 
      for key, value in self.__dict__.iteritems()]
15644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15645 
 
15646 
  def __eq__(self, other):
15647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15648 
 
15649 
  def __ne__(self, other):
15650 
    return not (self == other)
15651 
 
15652 
class authorizePickup_result:
15653 
  """
15654 
  Attributes:
15655 
   - success
15656 
   - ex
15657 
  """
15658 
 
15659 
  thrift_spec = (
15660 
    (0, TType.BOOL, 'success', None, None, ), # 0
15661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15662 
  )
15663 
 
15664 
  def __init__(self, success=None, ex=None,):
15665 
    self.success = success
15666 
    self.ex = ex
15667 
 
15668 
  def read(self, iprot):
15669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15671 
      return
15672 
    iprot.readStructBegin()
15673 
    while True:
15674 
      (fname, ftype, fid) = iprot.readFieldBegin()
15675 
      if ftype == TType.STOP:
15676 
        break
15677 
      if fid == 0:
15678 
        if ftype == TType.BOOL:
15679 
          self.success = iprot.readBool();
15680 
        else:
15681 
          iprot.skip(ftype)
15682 
      elif fid == 1:
15683 
        if ftype == TType.STRUCT:
15684 
          self.ex = TransactionServiceException()
15685 
          self.ex.read(iprot)
15686 
        else:
15687 
          iprot.skip(ftype)
15688 
      else:
15689 
        iprot.skip(ftype)
15690 
      iprot.readFieldEnd()
15691 
    iprot.readStructEnd()
15692 
 
15693 
  def write(self, oprot):
15694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15696 
      return
15697 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15698 
    if self.success is not None:
2536 chandransh 15699 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15700 
      oprot.writeBool(self.success)
15701 
      oprot.writeFieldEnd()
3431 rajveer 15702 
    if self.ex is not None:
2536 chandransh 15703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15704 
      self.ex.write(oprot)
15705 
      oprot.writeFieldEnd()
15706 
    oprot.writeFieldStop()
15707 
    oprot.writeStructEnd()
15708 
 
3431 rajveer 15709 
  def validate(self):
15710 
    return
15711 
 
15712 
 
2536 chandransh 15713 
  def __repr__(self):
15714 
    L = ['%s=%r' % (key, value)
15715 
      for key, value in self.__dict__.iteritems()]
15716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15717 
 
15718 
  def __eq__(self, other):
15719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15720 
 
15721 
  def __ne__(self, other):
15722 
    return not (self == other)
15723 
 
2764 chandransh 15724 
class markDoasAsPickedUp_args:
15725 
  """
15726 
  Attributes:
15727 
   - providerId
15728 
   - pickupDetails
15729 
  """
15730 
 
15731 
  thrift_spec = (
15732 
    None, # 0
15733 
    (1, TType.I64, 'providerId', None, None, ), # 1
15734 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15735 
  )
15736 
 
15737 
  def __init__(self, providerId=None, pickupDetails=None,):
15738 
    self.providerId = providerId
15739 
    self.pickupDetails = pickupDetails
15740 
 
15741 
  def read(self, iprot):
15742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15744 
      return
15745 
    iprot.readStructBegin()
15746 
    while True:
15747 
      (fname, ftype, fid) = iprot.readFieldBegin()
15748 
      if ftype == TType.STOP:
15749 
        break
15750 
      if fid == 1:
15751 
        if ftype == TType.I64:
15752 
          self.providerId = iprot.readI64();
15753 
        else:
15754 
          iprot.skip(ftype)
15755 
      elif fid == 2:
15756 
        if ftype == TType.MAP:
15757 
          self.pickupDetails = {}
5411 rajveer 15758 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15759 
          for _i354 in xrange(_size350):
15760 
            _key355 = iprot.readString();
15761 
            _val356 = iprot.readString();
15762 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15763 
          iprot.readMapEnd()
15764 
        else:
15765 
          iprot.skip(ftype)
15766 
      else:
15767 
        iprot.skip(ftype)
15768 
      iprot.readFieldEnd()
15769 
    iprot.readStructEnd()
15770 
 
15771 
  def write(self, oprot):
15772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15774 
      return
15775 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15776 
    if self.providerId is not None:
2764 chandransh 15777 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15778 
      oprot.writeI64(self.providerId)
15779 
      oprot.writeFieldEnd()
3431 rajveer 15780 
    if self.pickupDetails is not None:
2764 chandransh 15781 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15782 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15783 
      for kiter357,viter358 in self.pickupDetails.items():
15784 
        oprot.writeString(kiter357)
15785 
        oprot.writeString(viter358)
2764 chandransh 15786 
      oprot.writeMapEnd()
15787 
      oprot.writeFieldEnd()
15788 
    oprot.writeFieldStop()
15789 
    oprot.writeStructEnd()
15790 
 
3431 rajveer 15791 
  def validate(self):
15792 
    return
15793 
 
15794 
 
2764 chandransh 15795 
  def __repr__(self):
15796 
    L = ['%s=%r' % (key, value)
15797 
      for key, value in self.__dict__.iteritems()]
15798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15799 
 
15800 
  def __eq__(self, other):
15801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15802 
 
15803 
  def __ne__(self, other):
15804 
    return not (self == other)
15805 
 
15806 
class markDoasAsPickedUp_result:
4910 phani.kuma 15807 
 
15808 
  thrift_spec = (
15809 
  )
15810 
 
15811 
  def read(self, iprot):
15812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15814 
      return
15815 
    iprot.readStructBegin()
15816 
    while True:
15817 
      (fname, ftype, fid) = iprot.readFieldBegin()
15818 
      if ftype == TType.STOP:
15819 
        break
15820 
      else:
15821 
        iprot.skip(ftype)
15822 
      iprot.readFieldEnd()
15823 
    iprot.readStructEnd()
15824 
 
15825 
  def write(self, oprot):
15826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15828 
      return
15829 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15830 
    oprot.writeFieldStop()
15831 
    oprot.writeStructEnd()
15832 
 
15833 
  def validate(self):
15834 
    return
15835 
 
15836 
 
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 getDoasNotPickedUp_args:
2764 chandransh 15849 
  """
15850 
  Attributes:
4910 phani.kuma 15851 
   - providerId
15852 
  """
15853 
 
15854 
  thrift_spec = (
15855 
    None, # 0
15856 
    (1, TType.I64, 'providerId', None, None, ), # 1
15857 
  )
15858 
 
15859 
  def __init__(self, providerId=None,):
15860 
    self.providerId = providerId
15861 
 
15862 
  def read(self, iprot):
15863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15865 
      return
15866 
    iprot.readStructBegin()
15867 
    while True:
15868 
      (fname, ftype, fid) = iprot.readFieldBegin()
15869 
      if ftype == TType.STOP:
15870 
        break
15871 
      if fid == 1:
15872 
        if ftype == TType.I64:
15873 
          self.providerId = iprot.readI64();
15874 
        else:
15875 
          iprot.skip(ftype)
15876 
      else:
15877 
        iprot.skip(ftype)
15878 
      iprot.readFieldEnd()
15879 
    iprot.readStructEnd()
15880 
 
15881 
  def write(self, oprot):
15882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15884 
      return
15885 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15886 
    if self.providerId is not None:
15887 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15888 
      oprot.writeI64(self.providerId)
15889 
      oprot.writeFieldEnd()
15890 
    oprot.writeFieldStop()
15891 
    oprot.writeStructEnd()
15892 
 
15893 
  def validate(self):
15894 
    return
15895 
 
15896 
 
15897 
  def __repr__(self):
15898 
    L = ['%s=%r' % (key, value)
15899 
      for key, value in self.__dict__.iteritems()]
15900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15901 
 
15902 
  def __eq__(self, other):
15903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15904 
 
15905 
  def __ne__(self, other):
15906 
    return not (self == other)
15907 
 
15908 
class getDoasNotPickedUp_result:
15909 
  """
15910 
  Attributes:
2764 chandransh 15911 
   - success
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15916 
  )
15917 
 
15918 
  def __init__(self, success=None,):
15919 
    self.success = success
15920 
 
15921 
  def read(self, iprot):
15922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15924 
      return
15925 
    iprot.readStructBegin()
15926 
    while True:
15927 
      (fname, ftype, fid) = iprot.readFieldBegin()
15928 
      if ftype == TType.STOP:
15929 
        break
15930 
      if fid == 0:
15931 
        if ftype == TType.LIST:
15932 
          self.success = []
5411 rajveer 15933 
          (_etype362, _size359) = iprot.readListBegin()
15934 
          for _i363 in xrange(_size359):
15935 
            _elem364 = Order()
15936 
            _elem364.read(iprot)
15937 
            self.success.append(_elem364)
2764 chandransh 15938 
          iprot.readListEnd()
15939 
        else:
15940 
          iprot.skip(ftype)
15941 
      else:
15942 
        iprot.skip(ftype)
15943 
      iprot.readFieldEnd()
15944 
    iprot.readStructEnd()
15945 
 
15946 
  def write(self, oprot):
15947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15949 
      return
4910 phani.kuma 15950 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15951 
    if self.success is not None:
2764 chandransh 15952 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15953 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15954 
      for iter365 in self.success:
15955 
        iter365.write(oprot)
2764 chandransh 15956 
      oprot.writeListEnd()
15957 
      oprot.writeFieldEnd()
15958 
    oprot.writeFieldStop()
15959 
    oprot.writeStructEnd()
15960 
 
3431 rajveer 15961 
  def validate(self):
15962 
    return
15963 
 
15964 
 
2764 chandransh 15965 
  def __repr__(self):
15966 
    L = ['%s=%r' % (key, value)
15967 
      for key, value in self.__dict__.iteritems()]
15968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15969 
 
15970 
  def __eq__(self, other):
15971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15972 
 
15973 
  def __ne__(self, other):
15974 
    return not (self == other)
15975 
 
4741 phani.kuma 15976 
class markReturnOrdersAsPickedUp_args:
15977 
  """
15978 
  Attributes:
15979 
   - providerId
15980 
   - pickupDetails
15981 
  """
15982 
 
15983 
  thrift_spec = (
15984 
    None, # 0
15985 
    (1, TType.I64, 'providerId', None, None, ), # 1
15986 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15987 
  )
15988 
 
15989 
  def __init__(self, providerId=None, pickupDetails=None,):
15990 
    self.providerId = providerId
15991 
    self.pickupDetails = pickupDetails
15992 
 
15993 
  def read(self, iprot):
15994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15996 
      return
15997 
    iprot.readStructBegin()
15998 
    while True:
15999 
      (fname, ftype, fid) = iprot.readFieldBegin()
16000 
      if ftype == TType.STOP:
16001 
        break
16002 
      if fid == 1:
16003 
        if ftype == TType.I64:
16004 
          self.providerId = iprot.readI64();
16005 
        else:
16006 
          iprot.skip(ftype)
16007 
      elif fid == 2:
16008 
        if ftype == TType.MAP:
16009 
          self.pickupDetails = {}
5411 rajveer 16010 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
16011 
          for _i370 in xrange(_size366):
16012 
            _key371 = iprot.readString();
16013 
            _val372 = iprot.readString();
16014 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 16015 
          iprot.readMapEnd()
16016 
        else:
16017 
          iprot.skip(ftype)
16018 
      else:
16019 
        iprot.skip(ftype)
16020 
      iprot.readFieldEnd()
16021 
    iprot.readStructEnd()
16022 
 
16023 
  def write(self, oprot):
16024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16026 
      return
16027 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16028 
    if self.providerId is not None:
16029 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16030 
      oprot.writeI64(self.providerId)
16031 
      oprot.writeFieldEnd()
16032 
    if self.pickupDetails is not None:
16033 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16034 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 16035 
      for kiter373,viter374 in self.pickupDetails.items():
16036 
        oprot.writeString(kiter373)
16037 
        oprot.writeString(viter374)
4741 phani.kuma 16038 
      oprot.writeMapEnd()
16039 
      oprot.writeFieldEnd()
16040 
    oprot.writeFieldStop()
16041 
    oprot.writeStructEnd()
16042 
 
16043 
  def validate(self):
16044 
    return
16045 
 
16046 
 
16047 
  def __repr__(self):
16048 
    L = ['%s=%r' % (key, value)
16049 
      for key, value in self.__dict__.iteritems()]
16050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16051 
 
16052 
  def __eq__(self, other):
16053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16054 
 
16055 
  def __ne__(self, other):
16056 
    return not (self == other)
16057 
 
16058 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16059 
 
16060 
  thrift_spec = (
16061 
  )
16062 
 
16063 
  def read(self, iprot):
16064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16066 
      return
16067 
    iprot.readStructBegin()
16068 
    while True:
16069 
      (fname, ftype, fid) = iprot.readFieldBegin()
16070 
      if ftype == TType.STOP:
16071 
        break
16072 
      else:
16073 
        iprot.skip(ftype)
16074 
      iprot.readFieldEnd()
16075 
    iprot.readStructEnd()
16076 
 
16077 
  def write(self, oprot):
16078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16080 
      return
16081 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16082 
    oprot.writeFieldStop()
16083 
    oprot.writeStructEnd()
16084 
 
16085 
  def validate(self):
16086 
    return
16087 
 
16088 
 
16089 
  def __repr__(self):
16090 
    L = ['%s=%r' % (key, value)
16091 
      for key, value in self.__dict__.iteritems()]
16092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16093 
 
16094 
  def __eq__(self, other):
16095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16096 
 
16097 
  def __ne__(self, other):
16098 
    return not (self == other)
16099 
 
16100 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16101 
  """
16102 
  Attributes:
4910 phani.kuma 16103 
   - providerId
16104 
  """
16105 
 
16106 
  thrift_spec = (
16107 
    None, # 0
16108 
    (1, TType.I64, 'providerId', None, None, ), # 1
16109 
  )
16110 
 
16111 
  def __init__(self, providerId=None,):
16112 
    self.providerId = providerId
16113 
 
16114 
  def read(self, iprot):
16115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16117 
      return
16118 
    iprot.readStructBegin()
16119 
    while True:
16120 
      (fname, ftype, fid) = iprot.readFieldBegin()
16121 
      if ftype == TType.STOP:
16122 
        break
16123 
      if fid == 1:
16124 
        if ftype == TType.I64:
16125 
          self.providerId = iprot.readI64();
16126 
        else:
16127 
          iprot.skip(ftype)
16128 
      else:
16129 
        iprot.skip(ftype)
16130 
      iprot.readFieldEnd()
16131 
    iprot.readStructEnd()
16132 
 
16133 
  def write(self, oprot):
16134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16136 
      return
16137 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16138 
    if self.providerId is not None:
16139 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16140 
      oprot.writeI64(self.providerId)
16141 
      oprot.writeFieldEnd()
16142 
    oprot.writeFieldStop()
16143 
    oprot.writeStructEnd()
16144 
 
16145 
  def validate(self):
16146 
    return
16147 
 
16148 
 
16149 
  def __repr__(self):
16150 
    L = ['%s=%r' % (key, value)
16151 
      for key, value in self.__dict__.iteritems()]
16152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16153 
 
16154 
  def __eq__(self, other):
16155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16156 
 
16157 
  def __ne__(self, other):
16158 
    return not (self == other)
16159 
 
16160 
class getReturnOrdersNotPickedUp_result:
16161 
  """
16162 
  Attributes:
4741 phani.kuma 16163 
   - success
16164 
  """
16165 
 
16166 
  thrift_spec = (
16167 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16168 
  )
16169 
 
16170 
  def __init__(self, success=None,):
16171 
    self.success = success
16172 
 
16173 
  def read(self, iprot):
16174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16176 
      return
16177 
    iprot.readStructBegin()
16178 
    while True:
16179 
      (fname, ftype, fid) = iprot.readFieldBegin()
16180 
      if ftype == TType.STOP:
16181 
        break
16182 
      if fid == 0:
16183 
        if ftype == TType.LIST:
16184 
          self.success = []
5411 rajveer 16185 
          (_etype378, _size375) = iprot.readListBegin()
16186 
          for _i379 in xrange(_size375):
16187 
            _elem380 = Order()
16188 
            _elem380.read(iprot)
16189 
            self.success.append(_elem380)
4741 phani.kuma 16190 
          iprot.readListEnd()
16191 
        else:
16192 
          iprot.skip(ftype)
16193 
      else:
16194 
        iprot.skip(ftype)
16195 
      iprot.readFieldEnd()
16196 
    iprot.readStructEnd()
16197 
 
16198 
  def write(self, oprot):
16199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16201 
      return
4910 phani.kuma 16202 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16203 
    if self.success is not None:
16204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16206 
      for iter381 in self.success:
16207 
        iter381.write(oprot)
4741 phani.kuma 16208 
      oprot.writeListEnd()
16209 
      oprot.writeFieldEnd()
16210 
    oprot.writeFieldStop()
16211 
    oprot.writeStructEnd()
16212 
 
16213 
  def validate(self):
16214 
    return
16215 
 
16216 
 
16217 
  def __repr__(self):
16218 
    L = ['%s=%r' % (key, value)
16219 
      for key, value in self.__dict__.iteritems()]
16220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16221 
 
16222 
  def __eq__(self, other):
16223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16224 
 
16225 
  def __ne__(self, other):
16226 
    return not (self == other)
16227 
 
2616 chandransh 16228 
class receiveReturn_args:
2591 chandransh 16229 
  """
16230 
  Attributes:
16231 
   - orderId
4479 rajveer 16232 
   - receiveCondition
2591 chandransh 16233 
  """
2536 chandransh 16234 
 
2591 chandransh 16235 
  thrift_spec = (
16236 
    None, # 0
16237 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16238 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16239 
  )
16240 
 
4479 rajveer 16241 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16242 
    self.orderId = orderId
4479 rajveer 16243 
    self.receiveCondition = receiveCondition
2591 chandransh 16244 
 
16245 
  def read(self, iprot):
16246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16248 
      return
16249 
    iprot.readStructBegin()
16250 
    while True:
16251 
      (fname, ftype, fid) = iprot.readFieldBegin()
16252 
      if ftype == TType.STOP:
16253 
        break
16254 
      if fid == 1:
16255 
        if ftype == TType.I64:
16256 
          self.orderId = iprot.readI64();
16257 
        else:
16258 
          iprot.skip(ftype)
4479 rajveer 16259 
      elif fid == 2:
16260 
        if ftype == TType.I64:
16261 
          self.receiveCondition = iprot.readI64();
16262 
        else:
16263 
          iprot.skip(ftype)
2591 chandransh 16264 
      else:
16265 
        iprot.skip(ftype)
16266 
      iprot.readFieldEnd()
16267 
    iprot.readStructEnd()
16268 
 
16269 
  def write(self, oprot):
16270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16272 
      return
2616 chandransh 16273 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16274 
    if self.orderId is not None:
2591 chandransh 16275 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16276 
      oprot.writeI64(self.orderId)
16277 
      oprot.writeFieldEnd()
4479 rajveer 16278 
    if self.receiveCondition is not None:
16279 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16280 
      oprot.writeI64(self.receiveCondition)
16281 
      oprot.writeFieldEnd()
2591 chandransh 16282 
    oprot.writeFieldStop()
16283 
    oprot.writeStructEnd()
16284 
 
3431 rajveer 16285 
  def validate(self):
16286 
    return
16287 
 
16288 
 
2591 chandransh 16289 
  def __repr__(self):
16290 
    L = ['%s=%r' % (key, value)
16291 
      for key, value in self.__dict__.iteritems()]
16292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16293 
 
16294 
  def __eq__(self, other):
16295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16296 
 
16297 
  def __ne__(self, other):
16298 
    return not (self == other)
16299 
 
2616 chandransh 16300 
class receiveReturn_result:
2591 chandransh 16301 
  """
16302 
  Attributes:
16303 
   - success
16304 
   - ex
16305 
  """
16306 
 
16307 
  thrift_spec = (
16308 
    (0, TType.BOOL, 'success', None, None, ), # 0
16309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16310 
  )
16311 
 
16312 
  def __init__(self, success=None, ex=None,):
16313 
    self.success = success
16314 
    self.ex = ex
16315 
 
16316 
  def read(self, iprot):
16317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16319 
      return
16320 
    iprot.readStructBegin()
16321 
    while True:
16322 
      (fname, ftype, fid) = iprot.readFieldBegin()
16323 
      if ftype == TType.STOP:
16324 
        break
16325 
      if fid == 0:
16326 
        if ftype == TType.BOOL:
16327 
          self.success = iprot.readBool();
16328 
        else:
16329 
          iprot.skip(ftype)
16330 
      elif fid == 1:
16331 
        if ftype == TType.STRUCT:
16332 
          self.ex = TransactionServiceException()
16333 
          self.ex.read(iprot)
16334 
        else:
16335 
          iprot.skip(ftype)
16336 
      else:
16337 
        iprot.skip(ftype)
16338 
      iprot.readFieldEnd()
16339 
    iprot.readStructEnd()
16340 
 
16341 
  def write(self, oprot):
16342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16344 
      return
2616 chandransh 16345 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16346 
    if self.success is not None:
2591 chandransh 16347 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16348 
      oprot.writeBool(self.success)
16349 
      oprot.writeFieldEnd()
3431 rajveer 16350 
    if self.ex is not None:
2591 chandransh 16351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16352 
      self.ex.write(oprot)
16353 
      oprot.writeFieldEnd()
16354 
    oprot.writeFieldStop()
16355 
    oprot.writeStructEnd()
16356 
 
3431 rajveer 16357 
  def validate(self):
16358 
    return
16359 
 
16360 
 
2591 chandransh 16361 
  def __repr__(self):
16362 
    L = ['%s=%r' % (key, value)
16363 
      for key, value in self.__dict__.iteritems()]
16364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16365 
 
16366 
  def __eq__(self, other):
16367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16368 
 
16369 
  def __ne__(self, other):
16370 
    return not (self == other)
16371 
 
16372 
class validateDoa_args:
16373 
  """
16374 
  Attributes:
16375 
   - orderId
16376 
   - isValid
16377 
  """
16378 
 
16379 
  thrift_spec = (
16380 
    None, # 0
16381 
    (1, TType.I64, 'orderId', None, None, ), # 1
16382 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16383 
  )
16384 
 
16385 
  def __init__(self, orderId=None, isValid=None,):
16386 
    self.orderId = orderId
16387 
    self.isValid = isValid
16388 
 
16389 
  def read(self, iprot):
16390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16392 
      return
16393 
    iprot.readStructBegin()
16394 
    while True:
16395 
      (fname, ftype, fid) = iprot.readFieldBegin()
16396 
      if ftype == TType.STOP:
16397 
        break
16398 
      if fid == 1:
16399 
        if ftype == TType.I64:
16400 
          self.orderId = iprot.readI64();
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      elif fid == 2:
16404 
        if ftype == TType.BOOL:
16405 
          self.isValid = iprot.readBool();
16406 
        else:
16407 
          iprot.skip(ftype)
16408 
      else:
16409 
        iprot.skip(ftype)
16410 
      iprot.readFieldEnd()
16411 
    iprot.readStructEnd()
16412 
 
16413 
  def write(self, oprot):
16414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16416 
      return
16417 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16418 
    if self.orderId is not None:
2591 chandransh 16419 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16420 
      oprot.writeI64(self.orderId)
16421 
      oprot.writeFieldEnd()
3431 rajveer 16422 
    if self.isValid is not None:
2591 chandransh 16423 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16424 
      oprot.writeBool(self.isValid)
16425 
      oprot.writeFieldEnd()
16426 
    oprot.writeFieldStop()
16427 
    oprot.writeStructEnd()
16428 
 
3431 rajveer 16429 
  def validate(self):
16430 
    return
16431 
 
16432 
 
2591 chandransh 16433 
  def __repr__(self):
16434 
    L = ['%s=%r' % (key, value)
16435 
      for key, value in self.__dict__.iteritems()]
16436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16437 
 
16438 
  def __eq__(self, other):
16439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16440 
 
16441 
  def __ne__(self, other):
16442 
    return not (self == other)
16443 
 
16444 
class validateDoa_result:
16445 
  """
16446 
  Attributes:
16447 
   - success
16448 
   - ex
16449 
  """
16450 
 
16451 
  thrift_spec = (
16452 
    (0, TType.BOOL, 'success', None, None, ), # 0
16453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16454 
  )
16455 
 
16456 
  def __init__(self, success=None, ex=None,):
16457 
    self.success = success
16458 
    self.ex = ex
16459 
 
16460 
  def read(self, iprot):
16461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16463 
      return
16464 
    iprot.readStructBegin()
16465 
    while True:
16466 
      (fname, ftype, fid) = iprot.readFieldBegin()
16467 
      if ftype == TType.STOP:
16468 
        break
16469 
      if fid == 0:
16470 
        if ftype == TType.BOOL:
16471 
          self.success = iprot.readBool();
16472 
        else:
16473 
          iprot.skip(ftype)
16474 
      elif fid == 1:
16475 
        if ftype == TType.STRUCT:
16476 
          self.ex = TransactionServiceException()
16477 
          self.ex.read(iprot)
16478 
        else:
16479 
          iprot.skip(ftype)
16480 
      else:
16481 
        iprot.skip(ftype)
16482 
      iprot.readFieldEnd()
16483 
    iprot.readStructEnd()
16484 
 
16485 
  def write(self, oprot):
16486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16488 
      return
16489 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16490 
    if self.success is not None:
2591 chandransh 16491 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16492 
      oprot.writeBool(self.success)
16493 
      oprot.writeFieldEnd()
3431 rajveer 16494 
    if self.ex is not None:
2591 chandransh 16495 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16496 
      self.ex.write(oprot)
16497 
      oprot.writeFieldEnd()
16498 
    oprot.writeFieldStop()
16499 
    oprot.writeStructEnd()
16500 
 
3431 rajveer 16501 
  def validate(self):
16502 
    return
16503 
 
16504 
 
2591 chandransh 16505 
  def __repr__(self):
16506 
    L = ['%s=%r' % (key, value)
16507 
      for key, value in self.__dict__.iteritems()]
16508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16509 
 
16510 
  def __eq__(self, other):
16511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16512 
 
16513 
  def __ne__(self, other):
16514 
    return not (self == other)
16515 
 
4495 rajveer 16516 
class validateReturnProduct_args:
16517 
  """
16518 
  Attributes:
16519 
   - orderId
16520 
   - isUsable
16521 
  """
16522 
 
16523 
  thrift_spec = (
16524 
    None, # 0
16525 
    (1, TType.I64, 'orderId', None, None, ), # 1
16526 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16527 
  )
16528 
 
16529 
  def __init__(self, orderId=None, isUsable=None,):
16530 
    self.orderId = orderId
16531 
    self.isUsable = isUsable
16532 
 
16533 
  def read(self, iprot):
16534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16536 
      return
16537 
    iprot.readStructBegin()
16538 
    while True:
16539 
      (fname, ftype, fid) = iprot.readFieldBegin()
16540 
      if ftype == TType.STOP:
16541 
        break
16542 
      if fid == 1:
16543 
        if ftype == TType.I64:
16544 
          self.orderId = iprot.readI64();
16545 
        else:
16546 
          iprot.skip(ftype)
16547 
      elif fid == 2:
16548 
        if ftype == TType.BOOL:
16549 
          self.isUsable = iprot.readBool();
16550 
        else:
16551 
          iprot.skip(ftype)
16552 
      else:
16553 
        iprot.skip(ftype)
16554 
      iprot.readFieldEnd()
16555 
    iprot.readStructEnd()
16556 
 
16557 
  def write(self, oprot):
16558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16560 
      return
16561 
    oprot.writeStructBegin('validateReturnProduct_args')
16562 
    if self.orderId is not None:
16563 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16564 
      oprot.writeI64(self.orderId)
16565 
      oprot.writeFieldEnd()
16566 
    if self.isUsable is not None:
16567 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16568 
      oprot.writeBool(self.isUsable)
16569 
      oprot.writeFieldEnd()
16570 
    oprot.writeFieldStop()
16571 
    oprot.writeStructEnd()
16572 
 
16573 
  def validate(self):
16574 
    return
16575 
 
16576 
 
16577 
  def __repr__(self):
16578 
    L = ['%s=%r' % (key, value)
16579 
      for key, value in self.__dict__.iteritems()]
16580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16581 
 
16582 
  def __eq__(self, other):
16583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16584 
 
16585 
  def __ne__(self, other):
16586 
    return not (self == other)
16587 
 
16588 
class validateReturnProduct_result:
16589 
  """
16590 
  Attributes:
16591 
   - success
16592 
   - ex
16593 
  """
16594 
 
16595 
  thrift_spec = (
16596 
    (0, TType.BOOL, 'success', None, None, ), # 0
16597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16598 
  )
16599 
 
16600 
  def __init__(self, success=None, ex=None,):
16601 
    self.success = success
16602 
    self.ex = ex
16603 
 
16604 
  def read(self, iprot):
16605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16607 
      return
16608 
    iprot.readStructBegin()
16609 
    while True:
16610 
      (fname, ftype, fid) = iprot.readFieldBegin()
16611 
      if ftype == TType.STOP:
16612 
        break
16613 
      if fid == 0:
16614 
        if ftype == TType.BOOL:
16615 
          self.success = iprot.readBool();
16616 
        else:
16617 
          iprot.skip(ftype)
16618 
      elif fid == 1:
16619 
        if ftype == TType.STRUCT:
16620 
          self.ex = TransactionServiceException()
16621 
          self.ex.read(iprot)
16622 
        else:
16623 
          iprot.skip(ftype)
16624 
      else:
16625 
        iprot.skip(ftype)
16626 
      iprot.readFieldEnd()
16627 
    iprot.readStructEnd()
16628 
 
16629 
  def write(self, oprot):
16630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16632 
      return
16633 
    oprot.writeStructBegin('validateReturnProduct_result')
16634 
    if self.success is not None:
16635 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16636 
      oprot.writeBool(self.success)
16637 
      oprot.writeFieldEnd()
16638 
    if self.ex is not None:
16639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16640 
      self.ex.write(oprot)
16641 
      oprot.writeFieldEnd()
16642 
    oprot.writeFieldStop()
16643 
    oprot.writeStructEnd()
16644 
 
16645 
  def validate(self):
16646 
    return
16647 
 
16648 
 
16649 
  def __repr__(self):
16650 
    L = ['%s=%r' % (key, value)
16651 
      for key, value in self.__dict__.iteritems()]
16652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16653 
 
16654 
  def __eq__(self, other):
16655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16656 
 
16657 
  def __ne__(self, other):
16658 
    return not (self == other)
16659 
 
2616 chandransh 16660 
class reshipOrder_args:
16661 
  """
16662 
  Attributes:
16663 
   - orderId
16664 
  """
2591 chandransh 16665 
 
2616 chandransh 16666 
  thrift_spec = (
16667 
    None, # 0
16668 
    (1, TType.I64, 'orderId', None, None, ), # 1
16669 
  )
16670 
 
16671 
  def __init__(self, orderId=None,):
16672 
    self.orderId = orderId
16673 
 
16674 
  def read(self, iprot):
16675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16677 
      return
16678 
    iprot.readStructBegin()
16679 
    while True:
16680 
      (fname, ftype, fid) = iprot.readFieldBegin()
16681 
      if ftype == TType.STOP:
16682 
        break
16683 
      if fid == 1:
16684 
        if ftype == TType.I64:
16685 
          self.orderId = iprot.readI64();
16686 
        else:
16687 
          iprot.skip(ftype)
16688 
      else:
16689 
        iprot.skip(ftype)
16690 
      iprot.readFieldEnd()
16691 
    iprot.readStructEnd()
16692 
 
16693 
  def write(self, oprot):
16694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16696 
      return
16697 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16698 
    if self.orderId is not None:
2616 chandransh 16699 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16700 
      oprot.writeI64(self.orderId)
16701 
      oprot.writeFieldEnd()
16702 
    oprot.writeFieldStop()
16703 
    oprot.writeStructEnd()
16704 
 
3431 rajveer 16705 
  def validate(self):
16706 
    return
16707 
 
16708 
 
2616 chandransh 16709 
  def __repr__(self):
16710 
    L = ['%s=%r' % (key, value)
16711 
      for key, value in self.__dict__.iteritems()]
16712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16713 
 
16714 
  def __eq__(self, other):
16715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16716 
 
16717 
  def __ne__(self, other):
16718 
    return not (self == other)
16719 
 
16720 
class reshipOrder_result:
16721 
  """
16722 
  Attributes:
16723 
   - success
16724 
   - ex
16725 
  """
16726 
 
16727 
  thrift_spec = (
16728 
    (0, TType.I64, 'success', None, None, ), # 0
16729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16730 
  )
16731 
 
16732 
  def __init__(self, success=None, ex=None,):
16733 
    self.success = success
16734 
    self.ex = ex
16735 
 
16736 
  def read(self, iprot):
16737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16739 
      return
16740 
    iprot.readStructBegin()
16741 
    while True:
16742 
      (fname, ftype, fid) = iprot.readFieldBegin()
16743 
      if ftype == TType.STOP:
16744 
        break
16745 
      if fid == 0:
16746 
        if ftype == TType.I64:
16747 
          self.success = iprot.readI64();
16748 
        else:
16749 
          iprot.skip(ftype)
16750 
      elif fid == 1:
16751 
        if ftype == TType.STRUCT:
16752 
          self.ex = TransactionServiceException()
16753 
          self.ex.read(iprot)
16754 
        else:
16755 
          iprot.skip(ftype)
16756 
      else:
16757 
        iprot.skip(ftype)
16758 
      iprot.readFieldEnd()
16759 
    iprot.readStructEnd()
16760 
 
16761 
  def write(self, oprot):
16762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16764 
      return
16765 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16766 
    if self.success is not None:
2616 chandransh 16767 
      oprot.writeFieldBegin('success', TType.I64, 0)
16768 
      oprot.writeI64(self.success)
16769 
      oprot.writeFieldEnd()
3431 rajveer 16770 
    if self.ex is not None:
2616 chandransh 16771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16772 
      self.ex.write(oprot)
16773 
      oprot.writeFieldEnd()
16774 
    oprot.writeFieldStop()
16775 
    oprot.writeStructEnd()
16776 
 
3431 rajveer 16777 
  def validate(self):
16778 
    return
16779 
 
16780 
 
2616 chandransh 16781 
  def __repr__(self):
16782 
    L = ['%s=%r' % (key, value)
16783 
      for key, value in self.__dict__.iteritems()]
16784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16785 
 
16786 
  def __eq__(self, other):
16787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16788 
 
16789 
  def __ne__(self, other):
16790 
    return not (self == other)
16791 
 
16792 
class refundOrder_args:
16793 
  """
16794 
  Attributes:
16795 
   - orderId
3226 chandransh 16796 
   - refundedBy
16797 
   - reason
2616 chandransh 16798 
  """
16799 
 
16800 
  thrift_spec = (
16801 
    None, # 0
16802 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16803 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16804 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16805 
  )
16806 
 
3226 chandransh 16807 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16808 
    self.orderId = orderId
3226 chandransh 16809 
    self.refundedBy = refundedBy
16810 
    self.reason = reason
2616 chandransh 16811 
 
16812 
  def read(self, iprot):
16813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16815 
      return
16816 
    iprot.readStructBegin()
16817 
    while True:
16818 
      (fname, ftype, fid) = iprot.readFieldBegin()
16819 
      if ftype == TType.STOP:
16820 
        break
16821 
      if fid == 1:
16822 
        if ftype == TType.I64:
16823 
          self.orderId = iprot.readI64();
16824 
        else:
16825 
          iprot.skip(ftype)
3226 chandransh 16826 
      elif fid == 2:
16827 
        if ftype == TType.STRING:
16828 
          self.refundedBy = iprot.readString();
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      elif fid == 3:
16832 
        if ftype == TType.STRING:
16833 
          self.reason = iprot.readString();
16834 
        else:
16835 
          iprot.skip(ftype)
2616 chandransh 16836 
      else:
16837 
        iprot.skip(ftype)
16838 
      iprot.readFieldEnd()
16839 
    iprot.readStructEnd()
16840 
 
16841 
  def write(self, oprot):
16842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16844 
      return
16845 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16846 
    if self.orderId is not None:
2616 chandransh 16847 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16848 
      oprot.writeI64(self.orderId)
16849 
      oprot.writeFieldEnd()
3431 rajveer 16850 
    if self.refundedBy is not None:
3226 chandransh 16851 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16852 
      oprot.writeString(self.refundedBy)
16853 
      oprot.writeFieldEnd()
3431 rajveer 16854 
    if self.reason is not None:
3226 chandransh 16855 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16856 
      oprot.writeString(self.reason)
16857 
      oprot.writeFieldEnd()
2616 chandransh 16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
3431 rajveer 16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
2616 chandransh 16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
16876 
class refundOrder_result:
16877 
  """
16878 
  Attributes:
16879 
   - success
16880 
   - ex
16881 
  """
16882 
 
16883 
  thrift_spec = (
16884 
    (0, TType.BOOL, 'success', None, None, ), # 0
16885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16886 
  )
16887 
 
16888 
  def __init__(self, success=None, ex=None,):
16889 
    self.success = success
16890 
    self.ex = ex
16891 
 
16892 
  def read(self, iprot):
16893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16895 
      return
16896 
    iprot.readStructBegin()
16897 
    while True:
16898 
      (fname, ftype, fid) = iprot.readFieldBegin()
16899 
      if ftype == TType.STOP:
16900 
        break
16901 
      if fid == 0:
16902 
        if ftype == TType.BOOL:
16903 
          self.success = iprot.readBool();
16904 
        else:
16905 
          iprot.skip(ftype)
16906 
      elif fid == 1:
16907 
        if ftype == TType.STRUCT:
16908 
          self.ex = TransactionServiceException()
16909 
          self.ex.read(iprot)
16910 
        else:
16911 
          iprot.skip(ftype)
16912 
      else:
16913 
        iprot.skip(ftype)
16914 
      iprot.readFieldEnd()
16915 
    iprot.readStructEnd()
16916 
 
16917 
  def write(self, oprot):
16918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16920 
      return
16921 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16922 
    if self.success is not None:
2616 chandransh 16923 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16924 
      oprot.writeBool(self.success)
16925 
      oprot.writeFieldEnd()
3431 rajveer 16926 
    if self.ex is not None:
2616 chandransh 16927 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16928 
      self.ex.write(oprot)
16929 
      oprot.writeFieldEnd()
16930 
    oprot.writeFieldStop()
16931 
    oprot.writeStructEnd()
16932 
 
3431 rajveer 16933 
  def validate(self):
16934 
    return
16935 
 
16936 
 
2616 chandransh 16937 
  def __repr__(self):
16938 
    L = ['%s=%r' % (key, value)
16939 
      for key, value in self.__dict__.iteritems()]
16940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16941 
 
16942 
  def __eq__(self, other):
16943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16944 
 
16945 
  def __ne__(self, other):
16946 
    return not (self == other)
16947 
 
2690 chandransh 16948 
class getReturnOrders_args:
16949 
  """
16950 
  Attributes:
16951 
   - warehouseId
16952 
   - fromDate
16953 
   - toDate
16954 
  """
2616 chandransh 16955 
 
2690 chandransh 16956 
  thrift_spec = (
16957 
    None, # 0
16958 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16959 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16960 
    (3, TType.I64, 'toDate', None, None, ), # 3
16961 
  )
16962 
 
16963 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16964 
    self.warehouseId = warehouseId
16965 
    self.fromDate = fromDate
16966 
    self.toDate = toDate
16967 
 
16968 
  def read(self, iprot):
16969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16971 
      return
16972 
    iprot.readStructBegin()
16973 
    while True:
16974 
      (fname, ftype, fid) = iprot.readFieldBegin()
16975 
      if ftype == TType.STOP:
16976 
        break
16977 
      if fid == 1:
16978 
        if ftype == TType.I64:
16979 
          self.warehouseId = iprot.readI64();
16980 
        else:
16981 
          iprot.skip(ftype)
16982 
      elif fid == 2:
16983 
        if ftype == TType.I64:
16984 
          self.fromDate = iprot.readI64();
16985 
        else:
16986 
          iprot.skip(ftype)
16987 
      elif fid == 3:
16988 
        if ftype == TType.I64:
16989 
          self.toDate = iprot.readI64();
16990 
        else:
16991 
          iprot.skip(ftype)
16992 
      else:
16993 
        iprot.skip(ftype)
16994 
      iprot.readFieldEnd()
16995 
    iprot.readStructEnd()
16996 
 
16997 
  def write(self, oprot):
16998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17000 
      return
17001 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17002 
    if self.warehouseId is not None:
2690 chandransh 17003 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17004 
      oprot.writeI64(self.warehouseId)
17005 
      oprot.writeFieldEnd()
3431 rajveer 17006 
    if self.fromDate is not None:
2690 chandransh 17007 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17008 
      oprot.writeI64(self.fromDate)
17009 
      oprot.writeFieldEnd()
3431 rajveer 17010 
    if self.toDate is not None:
2690 chandransh 17011 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17012 
      oprot.writeI64(self.toDate)
17013 
      oprot.writeFieldEnd()
17014 
    oprot.writeFieldStop()
17015 
    oprot.writeStructEnd()
17016 
 
3431 rajveer 17017 
  def validate(self):
17018 
    return
17019 
 
17020 
 
2690 chandransh 17021 
  def __repr__(self):
17022 
    L = ['%s=%r' % (key, value)
17023 
      for key, value in self.__dict__.iteritems()]
17024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17025 
 
17026 
  def __eq__(self, other):
17027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17028 
 
17029 
  def __ne__(self, other):
17030 
    return not (self == other)
17031 
 
17032 
class getReturnOrders_result:
17033 
  """
17034 
  Attributes:
17035 
   - success
17036 
  """
17037 
 
17038 
  thrift_spec = (
17039 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17040 
  )
17041 
 
17042 
  def __init__(self, success=None,):
17043 
    self.success = success
17044 
 
17045 
  def read(self, iprot):
17046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17048 
      return
17049 
    iprot.readStructBegin()
17050 
    while True:
17051 
      (fname, ftype, fid) = iprot.readFieldBegin()
17052 
      if ftype == TType.STOP:
17053 
        break
17054 
      if fid == 0:
17055 
        if ftype == TType.LIST:
17056 
          self.success = []
5411 rajveer 17057 
          (_etype385, _size382) = iprot.readListBegin()
17058 
          for _i386 in xrange(_size382):
17059 
            _elem387 = ReturnOrder()
17060 
            _elem387.read(iprot)
17061 
            self.success.append(_elem387)
2690 chandransh 17062 
          iprot.readListEnd()
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17075 
    if self.success is not None:
2690 chandransh 17076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 17078 
      for iter388 in self.success:
17079 
        iter388.write(oprot)
2690 chandransh 17080 
      oprot.writeListEnd()
17081 
      oprot.writeFieldEnd()
17082 
    oprot.writeFieldStop()
17083 
    oprot.writeStructEnd()
17084 
 
3431 rajveer 17085 
  def validate(self):
17086 
    return
17087 
 
17088 
 
2690 chandransh 17089 
  def __repr__(self):
17090 
    L = ['%s=%r' % (key, value)
17091 
      for key, value in self.__dict__.iteritems()]
17092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17093 
 
17094 
  def __eq__(self, other):
17095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17096 
 
17097 
  def __ne__(self, other):
17098 
    return not (self == other)
17099 
 
5481 phani.kuma 17100 
class getAllReturnOrders_args:
17101 
  """
17102 
  Attributes:
17103 
   - onlyNotProcessed
17104 
   - fromDate
17105 
   - toDate
17106 
  """
17107 
 
17108 
  thrift_spec = (
17109 
    None, # 0
17110 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17111 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17112 
    (3, TType.I64, 'toDate', None, None, ), # 3
17113 
  )
17114 
 
17115 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17116 
    self.onlyNotProcessed = onlyNotProcessed
17117 
    self.fromDate = fromDate
17118 
    self.toDate = toDate
17119 
 
17120 
  def read(self, iprot):
17121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17123 
      return
17124 
    iprot.readStructBegin()
17125 
    while True:
17126 
      (fname, ftype, fid) = iprot.readFieldBegin()
17127 
      if ftype == TType.STOP:
17128 
        break
17129 
      if fid == 1:
17130 
        if ftype == TType.BOOL:
17131 
          self.onlyNotProcessed = iprot.readBool();
17132 
        else:
17133 
          iprot.skip(ftype)
17134 
      elif fid == 2:
17135 
        if ftype == TType.I64:
17136 
          self.fromDate = iprot.readI64();
17137 
        else:
17138 
          iprot.skip(ftype)
17139 
      elif fid == 3:
17140 
        if ftype == TType.I64:
17141 
          self.toDate = iprot.readI64();
17142 
        else:
17143 
          iprot.skip(ftype)
17144 
      else:
17145 
        iprot.skip(ftype)
17146 
      iprot.readFieldEnd()
17147 
    iprot.readStructEnd()
17148 
 
17149 
  def write(self, oprot):
17150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17152 
      return
17153 
    oprot.writeStructBegin('getAllReturnOrders_args')
17154 
    if self.onlyNotProcessed is not None:
17155 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17156 
      oprot.writeBool(self.onlyNotProcessed)
17157 
      oprot.writeFieldEnd()
17158 
    if self.fromDate is not None:
17159 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17160 
      oprot.writeI64(self.fromDate)
17161 
      oprot.writeFieldEnd()
17162 
    if self.toDate is not None:
17163 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17164 
      oprot.writeI64(self.toDate)
17165 
      oprot.writeFieldEnd()
17166 
    oprot.writeFieldStop()
17167 
    oprot.writeStructEnd()
17168 
 
17169 
  def validate(self):
17170 
    return
17171 
 
17172 
 
17173 
  def __repr__(self):
17174 
    L = ['%s=%r' % (key, value)
17175 
      for key, value in self.__dict__.iteritems()]
17176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17177 
 
17178 
  def __eq__(self, other):
17179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17180 
 
17181 
  def __ne__(self, other):
17182 
    return not (self == other)
17183 
 
17184 
class getAllReturnOrders_result:
17185 
  """
17186 
  Attributes:
17187 
   - success
17188 
  """
17189 
 
17190 
  thrift_spec = (
17191 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17192 
  )
17193 
 
17194 
  def __init__(self, success=None,):
17195 
    self.success = success
17196 
 
17197 
  def read(self, iprot):
17198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17200 
      return
17201 
    iprot.readStructBegin()
17202 
    while True:
17203 
      (fname, ftype, fid) = iprot.readFieldBegin()
17204 
      if ftype == TType.STOP:
17205 
        break
17206 
      if fid == 0:
17207 
        if ftype == TType.LIST:
17208 
          self.success = []
17209 
          (_etype392, _size389) = iprot.readListBegin()
17210 
          for _i393 in xrange(_size389):
17211 
            _elem394 = ReturnOrder()
17212 
            _elem394.read(iprot)
17213 
            self.success.append(_elem394)
17214 
          iprot.readListEnd()
17215 
        else:
17216 
          iprot.skip(ftype)
17217 
      else:
17218 
        iprot.skip(ftype)
17219 
      iprot.readFieldEnd()
17220 
    iprot.readStructEnd()
17221 
 
17222 
  def write(self, oprot):
17223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17225 
      return
17226 
    oprot.writeStructBegin('getAllReturnOrders_result')
17227 
    if self.success is not None:
17228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17230 
      for iter395 in self.success:
17231 
        iter395.write(oprot)
17232 
      oprot.writeListEnd()
17233 
      oprot.writeFieldEnd()
17234 
    oprot.writeFieldStop()
17235 
    oprot.writeStructEnd()
17236 
 
17237 
  def validate(self):
17238 
    return
17239 
 
17240 
 
17241 
  def __repr__(self):
17242 
    L = ['%s=%r' % (key, value)
17243 
      for key, value in self.__dict__.iteritems()]
17244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17245 
 
17246 
  def __eq__(self, other):
17247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17248 
 
17249 
  def __ne__(self, other):
17250 
    return not (self == other)
17251 
 
2700 chandransh 17252 
class getReturnOrder_args:
17253 
  """
17254 
  Attributes:
17255 
   - id
17256 
  """
17257 
 
17258 
  thrift_spec = (
17259 
    None, # 0
17260 
    (1, TType.I64, 'id', None, None, ), # 1
17261 
  )
17262 
 
17263 
  def __init__(self, id=None,):
17264 
    self.id = id
17265 
 
17266 
  def read(self, iprot):
17267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17269 
      return
17270 
    iprot.readStructBegin()
17271 
    while True:
17272 
      (fname, ftype, fid) = iprot.readFieldBegin()
17273 
      if ftype == TType.STOP:
17274 
        break
17275 
      if fid == 1:
17276 
        if ftype == TType.I64:
17277 
          self.id = iprot.readI64();
17278 
        else:
17279 
          iprot.skip(ftype)
17280 
      else:
17281 
        iprot.skip(ftype)
17282 
      iprot.readFieldEnd()
17283 
    iprot.readStructEnd()
17284 
 
17285 
  def write(self, oprot):
17286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17288 
      return
17289 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17290 
    if self.id is not None:
2700 chandransh 17291 
      oprot.writeFieldBegin('id', TType.I64, 1)
17292 
      oprot.writeI64(self.id)
17293 
      oprot.writeFieldEnd()
17294 
    oprot.writeFieldStop()
17295 
    oprot.writeStructEnd()
17296 
 
3431 rajveer 17297 
  def validate(self):
17298 
    return
17299 
 
17300 
 
2700 chandransh 17301 
  def __repr__(self):
17302 
    L = ['%s=%r' % (key, value)
17303 
      for key, value in self.__dict__.iteritems()]
17304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17305 
 
17306 
  def __eq__(self, other):
17307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17308 
 
17309 
  def __ne__(self, other):
17310 
    return not (self == other)
17311 
 
17312 
class getReturnOrder_result:
17313 
  """
17314 
  Attributes:
17315 
   - success
17316 
   - ex
17317 
  """
17318 
 
17319 
  thrift_spec = (
17320 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17321 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17322 
  )
17323 
 
17324 
  def __init__(self, success=None, ex=None,):
17325 
    self.success = success
17326 
    self.ex = ex
17327 
 
17328 
  def read(self, iprot):
17329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17331 
      return
17332 
    iprot.readStructBegin()
17333 
    while True:
17334 
      (fname, ftype, fid) = iprot.readFieldBegin()
17335 
      if ftype == TType.STOP:
17336 
        break
17337 
      if fid == 0:
17338 
        if ftype == TType.STRUCT:
17339 
          self.success = ReturnOrder()
17340 
          self.success.read(iprot)
17341 
        else:
17342 
          iprot.skip(ftype)
17343 
      elif fid == 1:
17344 
        if ftype == TType.STRUCT:
17345 
          self.ex = TransactionServiceException()
17346 
          self.ex.read(iprot)
17347 
        else:
17348 
          iprot.skip(ftype)
17349 
      else:
17350 
        iprot.skip(ftype)
17351 
      iprot.readFieldEnd()
17352 
    iprot.readStructEnd()
17353 
 
17354 
  def write(self, oprot):
17355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17357 
      return
17358 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17359 
    if self.success is not None:
2700 chandransh 17360 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17361 
      self.success.write(oprot)
17362 
      oprot.writeFieldEnd()
3431 rajveer 17363 
    if self.ex is not None:
2700 chandransh 17364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17365 
      self.ex.write(oprot)
17366 
      oprot.writeFieldEnd()
17367 
    oprot.writeFieldStop()
17368 
    oprot.writeStructEnd()
17369 
 
3431 rajveer 17370 
  def validate(self):
17371 
    return
17372 
 
17373 
 
2700 chandransh 17374 
  def __repr__(self):
17375 
    L = ['%s=%r' % (key, value)
17376 
      for key, value in self.__dict__.iteritems()]
17377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17378 
 
17379 
  def __eq__(self, other):
17380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17381 
 
17382 
  def __ne__(self, other):
17383 
    return not (self == other)
17384 
 
2690 chandransh 17385 
class processReturn_args:
17386 
  """
17387 
  Attributes:
17388 
   - returnOrderId
17389 
  """
17390 
 
17391 
  thrift_spec = (
17392 
    None, # 0
17393 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17394 
  )
17395 
 
17396 
  def __init__(self, returnOrderId=None,):
17397 
    self.returnOrderId = returnOrderId
17398 
 
17399 
  def read(self, iprot):
17400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17402 
      return
17403 
    iprot.readStructBegin()
17404 
    while True:
17405 
      (fname, ftype, fid) = iprot.readFieldBegin()
17406 
      if ftype == TType.STOP:
17407 
        break
17408 
      if fid == 1:
17409 
        if ftype == TType.I64:
17410 
          self.returnOrderId = iprot.readI64();
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      else:
17414 
        iprot.skip(ftype)
17415 
      iprot.readFieldEnd()
17416 
    iprot.readStructEnd()
17417 
 
17418 
  def write(self, oprot):
17419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17421 
      return
17422 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17423 
    if self.returnOrderId is not None:
2690 chandransh 17424 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17425 
      oprot.writeI64(self.returnOrderId)
17426 
      oprot.writeFieldEnd()
17427 
    oprot.writeFieldStop()
17428 
    oprot.writeStructEnd()
17429 
 
3431 rajveer 17430 
  def validate(self):
17431 
    return
17432 
 
17433 
 
2690 chandransh 17434 
  def __repr__(self):
17435 
    L = ['%s=%r' % (key, value)
17436 
      for key, value in self.__dict__.iteritems()]
17437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17438 
 
17439 
  def __eq__(self, other):
17440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17441 
 
17442 
  def __ne__(self, other):
17443 
    return not (self == other)
17444 
 
17445 
class processReturn_result:
17446 
  """
17447 
  Attributes:
17448 
   - ex
17449 
  """
17450 
 
17451 
  thrift_spec = (
17452 
    None, # 0
17453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17454 
  )
17455 
 
17456 
  def __init__(self, ex=None,):
17457 
    self.ex = ex
17458 
 
17459 
  def read(self, iprot):
17460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17462 
      return
17463 
    iprot.readStructBegin()
17464 
    while True:
17465 
      (fname, ftype, fid) = iprot.readFieldBegin()
17466 
      if ftype == TType.STOP:
17467 
        break
17468 
      if fid == 1:
17469 
        if ftype == TType.STRUCT:
17470 
          self.ex = TransactionServiceException()
17471 
          self.ex.read(iprot)
17472 
        else:
17473 
          iprot.skip(ftype)
17474 
      else:
17475 
        iprot.skip(ftype)
17476 
      iprot.readFieldEnd()
17477 
    iprot.readStructEnd()
17478 
 
17479 
  def write(self, oprot):
17480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17482 
      return
17483 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17484 
    if self.ex is not None:
2690 chandransh 17485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17486 
      self.ex.write(oprot)
17487 
      oprot.writeFieldEnd()
17488 
    oprot.writeFieldStop()
17489 
    oprot.writeStructEnd()
17490 
 
3431 rajveer 17491 
  def validate(self):
17492 
    return
17493 
 
17494 
 
2690 chandransh 17495 
  def __repr__(self):
17496 
    L = ['%s=%r' % (key, value)
17497 
      for key, value in self.__dict__.iteritems()]
17498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17499 
 
17500 
  def __eq__(self, other):
17501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17502 
 
17503 
  def __ne__(self, other):
17504 
    return not (self == other)
17505 
 
3451 chandransh 17506 
class updateWeight_args:
17507 
  """
17508 
  Attributes:
17509 
   - orderId
17510 
   - weight
17511 
  """
17512 
 
17513 
  thrift_spec = (
17514 
    None, # 0
17515 
    (1, TType.I64, 'orderId', None, None, ), # 1
17516 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17517 
  )
17518 
 
17519 
  def __init__(self, orderId=None, weight=None,):
17520 
    self.orderId = orderId
17521 
    self.weight = weight
17522 
 
17523 
  def read(self, iprot):
17524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17526 
      return
17527 
    iprot.readStructBegin()
17528 
    while True:
17529 
      (fname, ftype, fid) = iprot.readFieldBegin()
17530 
      if ftype == TType.STOP:
17531 
        break
17532 
      if fid == 1:
17533 
        if ftype == TType.I64:
17534 
          self.orderId = iprot.readI64();
17535 
        else:
17536 
          iprot.skip(ftype)
17537 
      elif fid == 2:
17538 
        if ftype == TType.DOUBLE:
17539 
          self.weight = iprot.readDouble();
17540 
        else:
17541 
          iprot.skip(ftype)
17542 
      else:
17543 
        iprot.skip(ftype)
17544 
      iprot.readFieldEnd()
17545 
    iprot.readStructEnd()
17546 
 
17547 
  def write(self, oprot):
17548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17550 
      return
17551 
    oprot.writeStructBegin('updateWeight_args')
17552 
    if self.orderId is not None:
17553 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17554 
      oprot.writeI64(self.orderId)
17555 
      oprot.writeFieldEnd()
17556 
    if self.weight is not None:
17557 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17558 
      oprot.writeDouble(self.weight)
17559 
      oprot.writeFieldEnd()
17560 
    oprot.writeFieldStop()
17561 
    oprot.writeStructEnd()
17562 
 
17563 
  def validate(self):
17564 
    return
17565 
 
17566 
 
17567 
  def __repr__(self):
17568 
    L = ['%s=%r' % (key, value)
17569 
      for key, value in self.__dict__.iteritems()]
17570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17571 
 
17572 
  def __eq__(self, other):
17573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17574 
 
17575 
  def __ne__(self, other):
17576 
    return not (self == other)
17577 
 
17578 
class updateWeight_result:
17579 
  """
17580 
  Attributes:
17581 
   - success
17582 
   - ex
17583 
  """
17584 
 
17585 
  thrift_spec = (
17586 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17588 
  )
17589 
 
17590 
  def __init__(self, success=None, ex=None,):
17591 
    self.success = success
17592 
    self.ex = ex
17593 
 
17594 
  def read(self, iprot):
17595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17597 
      return
17598 
    iprot.readStructBegin()
17599 
    while True:
17600 
      (fname, ftype, fid) = iprot.readFieldBegin()
17601 
      if ftype == TType.STOP:
17602 
        break
17603 
      if fid == 0:
17604 
        if ftype == TType.STRUCT:
17605 
          self.success = Order()
17606 
          self.success.read(iprot)
17607 
        else:
17608 
          iprot.skip(ftype)
17609 
      elif fid == 1:
17610 
        if ftype == TType.STRUCT:
17611 
          self.ex = TransactionServiceException()
17612 
          self.ex.read(iprot)
17613 
        else:
17614 
          iprot.skip(ftype)
17615 
      else:
17616 
        iprot.skip(ftype)
17617 
      iprot.readFieldEnd()
17618 
    iprot.readStructEnd()
17619 
 
17620 
  def write(self, oprot):
17621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17623 
      return
17624 
    oprot.writeStructBegin('updateWeight_result')
17625 
    if self.success is not None:
17626 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17627 
      self.success.write(oprot)
17628 
      oprot.writeFieldEnd()
17629 
    if self.ex is not None:
17630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17631 
      self.ex.write(oprot)
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
3469 chandransh 17650 
 
17651 
class changeItem_args:
17652 
  """
17653 
  Attributes:
17654 
   - orderId
17655 
   - itemId
17656 
  """
17657 
 
17658 
  thrift_spec = (
17659 
    None, # 0
17660 
    (1, TType.I64, 'orderId', None, None, ), # 1
17661 
    (2, TType.I64, 'itemId', None, None, ), # 2
17662 
  )
17663 
 
17664 
  def __init__(self, orderId=None, itemId=None,):
17665 
    self.orderId = orderId
17666 
    self.itemId = itemId
17667 
 
17668 
  def read(self, iprot):
17669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17671 
      return
17672 
    iprot.readStructBegin()
17673 
    while True:
17674 
      (fname, ftype, fid) = iprot.readFieldBegin()
17675 
      if ftype == TType.STOP:
17676 
        break
17677 
      if fid == 1:
17678 
        if ftype == TType.I64:
17679 
          self.orderId = iprot.readI64();
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      elif fid == 2:
17683 
        if ftype == TType.I64:
17684 
          self.itemId = iprot.readI64();
17685 
        else:
17686 
          iprot.skip(ftype)
17687 
      else:
17688 
        iprot.skip(ftype)
17689 
      iprot.readFieldEnd()
17690 
    iprot.readStructEnd()
17691 
 
17692 
  def write(self, oprot):
17693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17695 
      return
17696 
    oprot.writeStructBegin('changeItem_args')
17697 
    if self.orderId is not None:
17698 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17699 
      oprot.writeI64(self.orderId)
17700 
      oprot.writeFieldEnd()
17701 
    if self.itemId is not None:
17702 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17703 
      oprot.writeI64(self.itemId)
17704 
      oprot.writeFieldEnd()
17705 
    oprot.writeFieldStop()
17706 
    oprot.writeStructEnd()
17707 
 
17708 
  def validate(self):
17709 
    return
17710 
 
17711 
 
17712 
  def __repr__(self):
17713 
    L = ['%s=%r' % (key, value)
17714 
      for key, value in self.__dict__.iteritems()]
17715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17716 
 
17717 
  def __eq__(self, other):
17718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17719 
 
17720 
  def __ne__(self, other):
17721 
    return not (self == other)
17722 
 
17723 
class changeItem_result:
17724 
  """
17725 
  Attributes:
17726 
   - success
17727 
   - ex
17728 
  """
17729 
 
17730 
  thrift_spec = (
17731 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17733 
  )
17734 
 
17735 
  def __init__(self, success=None, ex=None,):
17736 
    self.success = success
17737 
    self.ex = ex
17738 
 
17739 
  def read(self, iprot):
17740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17742 
      return
17743 
    iprot.readStructBegin()
17744 
    while True:
17745 
      (fname, ftype, fid) = iprot.readFieldBegin()
17746 
      if ftype == TType.STOP:
17747 
        break
17748 
      if fid == 0:
17749 
        if ftype == TType.STRUCT:
17750 
          self.success = Order()
17751 
          self.success.read(iprot)
17752 
        else:
17753 
          iprot.skip(ftype)
17754 
      elif fid == 1:
17755 
        if ftype == TType.STRUCT:
17756 
          self.ex = TransactionServiceException()
17757 
          self.ex.read(iprot)
17758 
        else:
17759 
          iprot.skip(ftype)
17760 
      else:
17761 
        iprot.skip(ftype)
17762 
      iprot.readFieldEnd()
17763 
    iprot.readStructEnd()
17764 
 
17765 
  def write(self, oprot):
17766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17768 
      return
17769 
    oprot.writeStructBegin('changeItem_result')
17770 
    if self.success is not None:
17771 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17772 
      self.success.write(oprot)
17773 
      oprot.writeFieldEnd()
17774 
    if self.ex is not None:
17775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17776 
      self.ex.write(oprot)
17777 
      oprot.writeFieldEnd()
17778 
    oprot.writeFieldStop()
17779 
    oprot.writeStructEnd()
17780 
 
17781 
  def validate(self):
17782 
    return
17783 
 
17784 
 
17785 
  def __repr__(self):
17786 
    L = ['%s=%r' % (key, value)
17787 
      for key, value in self.__dict__.iteritems()]
17788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17789 
 
17790 
  def __eq__(self, other):
17791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17792 
 
17793 
  def __ne__(self, other):
17794 
    return not (self == other)
17795 
 
17796 
class shiftToWarehouse_args:
17797 
  """
17798 
  Attributes:
17799 
   - orderId
17800 
   - warehouseId
17801 
  """
17802 
 
17803 
  thrift_spec = (
17804 
    None, # 0
17805 
    (1, TType.I64, 'orderId', None, None, ), # 1
17806 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17807 
  )
17808 
 
17809 
  def __init__(self, orderId=None, warehouseId=None,):
17810 
    self.orderId = orderId
17811 
    self.warehouseId = warehouseId
17812 
 
17813 
  def read(self, iprot):
17814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17816 
      return
17817 
    iprot.readStructBegin()
17818 
    while True:
17819 
      (fname, ftype, fid) = iprot.readFieldBegin()
17820 
      if ftype == TType.STOP:
17821 
        break
17822 
      if fid == 1:
17823 
        if ftype == TType.I64:
17824 
          self.orderId = iprot.readI64();
17825 
        else:
17826 
          iprot.skip(ftype)
17827 
      elif fid == 2:
17828 
        if ftype == TType.I64:
17829 
          self.warehouseId = iprot.readI64();
17830 
        else:
17831 
          iprot.skip(ftype)
17832 
      else:
17833 
        iprot.skip(ftype)
17834 
      iprot.readFieldEnd()
17835 
    iprot.readStructEnd()
17836 
 
17837 
  def write(self, oprot):
17838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17840 
      return
17841 
    oprot.writeStructBegin('shiftToWarehouse_args')
17842 
    if self.orderId is not None:
17843 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17844 
      oprot.writeI64(self.orderId)
17845 
      oprot.writeFieldEnd()
17846 
    if self.warehouseId is not None:
17847 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17848 
      oprot.writeI64(self.warehouseId)
17849 
      oprot.writeFieldEnd()
17850 
    oprot.writeFieldStop()
17851 
    oprot.writeStructEnd()
17852 
 
17853 
  def validate(self):
17854 
    return
17855 
 
17856 
 
17857 
  def __repr__(self):
17858 
    L = ['%s=%r' % (key, value)
17859 
      for key, value in self.__dict__.iteritems()]
17860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17861 
 
17862 
  def __eq__(self, other):
17863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17864 
 
17865 
  def __ne__(self, other):
17866 
    return not (self == other)
17867 
 
17868 
class shiftToWarehouse_result:
17869 
  """
17870 
  Attributes:
17871 
   - success
17872 
   - ex
17873 
  """
17874 
 
17875 
  thrift_spec = (
17876 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17878 
  )
17879 
 
17880 
  def __init__(self, success=None, ex=None,):
17881 
    self.success = success
17882 
    self.ex = ex
17883 
 
17884 
  def read(self, iprot):
17885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17887 
      return
17888 
    iprot.readStructBegin()
17889 
    while True:
17890 
      (fname, ftype, fid) = iprot.readFieldBegin()
17891 
      if ftype == TType.STOP:
17892 
        break
17893 
      if fid == 0:
17894 
        if ftype == TType.STRUCT:
17895 
          self.success = Order()
17896 
          self.success.read(iprot)
17897 
        else:
17898 
          iprot.skip(ftype)
17899 
      elif fid == 1:
17900 
        if ftype == TType.STRUCT:
17901 
          self.ex = TransactionServiceException()
17902 
          self.ex.read(iprot)
17903 
        else:
17904 
          iprot.skip(ftype)
17905 
      else:
17906 
        iprot.skip(ftype)
17907 
      iprot.readFieldEnd()
17908 
    iprot.readStructEnd()
17909 
 
17910 
  def write(self, oprot):
17911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17913 
      return
17914 
    oprot.writeStructBegin('shiftToWarehouse_result')
17915 
    if self.success is not None:
17916 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17917 
      self.success.write(oprot)
17918 
      oprot.writeFieldEnd()
17919 
    if self.ex is not None:
17920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17921 
      self.ex.write(oprot)
17922 
      oprot.writeFieldEnd()
17923 
    oprot.writeFieldStop()
17924 
    oprot.writeStructEnd()
17925 
 
17926 
  def validate(self):
17927 
    return
17928 
 
17929 
 
17930 
  def __repr__(self):
17931 
    L = ['%s=%r' % (key, value)
17932 
      for key, value in self.__dict__.iteritems()]
17933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17934 
 
17935 
  def __eq__(self, other):
17936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17937 
 
17938 
  def __ne__(self, other):
17939 
    return not (self == other)
3553 chandransh 17940 
 
17941 
class addDelayReason_args:
17942 
  """
17943 
  Attributes:
17944 
   - orderId
17945 
   - delayReason
3986 chandransh 17946 
   - furtherDelay
4647 rajveer 17947 
   - delayReasonText
3553 chandransh 17948 
  """
17949 
 
17950 
  thrift_spec = (
17951 
    None, # 0
17952 
    (1, TType.I64, 'orderId', None, None, ), # 1
17953 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17954 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17955 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17956 
  )
17957 
 
4647 rajveer 17958 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17959 
    self.orderId = orderId
17960 
    self.delayReason = delayReason
3986 chandransh 17961 
    self.furtherDelay = furtherDelay
4647 rajveer 17962 
    self.delayReasonText = delayReasonText
3553 chandransh 17963 
 
17964 
  def read(self, iprot):
17965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17967 
      return
17968 
    iprot.readStructBegin()
17969 
    while True:
17970 
      (fname, ftype, fid) = iprot.readFieldBegin()
17971 
      if ftype == TType.STOP:
17972 
        break
17973 
      if fid == 1:
17974 
        if ftype == TType.I64:
17975 
          self.orderId = iprot.readI64();
17976 
        else:
17977 
          iprot.skip(ftype)
17978 
      elif fid == 2:
17979 
        if ftype == TType.I32:
17980 
          self.delayReason = iprot.readI32();
17981 
        else:
17982 
          iprot.skip(ftype)
3986 chandransh 17983 
      elif fid == 3:
17984 
        if ftype == TType.I64:
17985 
          self.furtherDelay = iprot.readI64();
17986 
        else:
17987 
          iprot.skip(ftype)
4647 rajveer 17988 
      elif fid == 4:
17989 
        if ftype == TType.STRING:
17990 
          self.delayReasonText = iprot.readString();
17991 
        else:
17992 
          iprot.skip(ftype)
3553 chandransh 17993 
      else:
17994 
        iprot.skip(ftype)
17995 
      iprot.readFieldEnd()
17996 
    iprot.readStructEnd()
17997 
 
17998 
  def write(self, oprot):
17999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18001 
      return
18002 
    oprot.writeStructBegin('addDelayReason_args')
18003 
    if self.orderId is not None:
18004 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18005 
      oprot.writeI64(self.orderId)
18006 
      oprot.writeFieldEnd()
18007 
    if self.delayReason is not None:
18008 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18009 
      oprot.writeI32(self.delayReason)
18010 
      oprot.writeFieldEnd()
3986 chandransh 18011 
    if self.furtherDelay is not None:
18012 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18013 
      oprot.writeI64(self.furtherDelay)
18014 
      oprot.writeFieldEnd()
4647 rajveer 18015 
    if self.delayReasonText is not None:
18016 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18017 
      oprot.writeString(self.delayReasonText)
18018 
      oprot.writeFieldEnd()
3553 chandransh 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 
 
18037 
class addDelayReason_result:
18038 
  """
18039 
  Attributes:
18040 
   - success
18041 
   - ex
18042 
  """
18043 
 
18044 
  thrift_spec = (
18045 
    (0, TType.BOOL, 'success', None, None, ), # 0
18046 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18047 
  )
18048 
 
18049 
  def __init__(self, success=None, ex=None,):
18050 
    self.success = success
18051 
    self.ex = ex
18052 
 
18053 
  def read(self, iprot):
18054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18056 
      return
18057 
    iprot.readStructBegin()
18058 
    while True:
18059 
      (fname, ftype, fid) = iprot.readFieldBegin()
18060 
      if ftype == TType.STOP:
18061 
        break
18062 
      if fid == 0:
18063 
        if ftype == TType.BOOL:
18064 
          self.success = iprot.readBool();
18065 
        else:
18066 
          iprot.skip(ftype)
18067 
      elif fid == 1:
18068 
        if ftype == TType.STRUCT:
18069 
          self.ex = TransactionServiceException()
18070 
          self.ex.read(iprot)
18071 
        else:
18072 
          iprot.skip(ftype)
18073 
      else:
18074 
        iprot.skip(ftype)
18075 
      iprot.readFieldEnd()
18076 
    iprot.readStructEnd()
18077 
 
18078 
  def write(self, oprot):
18079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18081 
      return
18082 
    oprot.writeStructBegin('addDelayReason_result')
18083 
    if self.success is not None:
18084 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18085 
      oprot.writeBool(self.success)
18086 
      oprot.writeFieldEnd()
18087 
    if self.ex is not None:
18088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18089 
      self.ex.write(oprot)
18090 
      oprot.writeFieldEnd()
18091 
    oprot.writeFieldStop()
18092 
    oprot.writeStructEnd()
18093 
 
18094 
  def validate(self):
18095 
    return
18096 
 
18097 
 
18098 
  def __repr__(self):
18099 
    L = ['%s=%r' % (key, value)
18100 
      for key, value in self.__dict__.iteritems()]
18101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18102 
 
18103 
  def __eq__(self, other):
18104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18105 
 
18106 
  def __ne__(self, other):
18107 
    return not (self == other)
3956 chandransh 18108 
 
18109 
class reconcileCodCollection_args:
18110 
  """
18111 
  Attributes:
18112 
   - collectedAmountMap
18113 
   - xferBy
18114 
   - xferTxnId
18115 
   - xferDate
18116 
  """
18117 
 
18118 
  thrift_spec = (
18119 
    None, # 0
18120 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18121 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18122 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18123 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18124 
  )
18125 
 
18126 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18127 
    self.collectedAmountMap = collectedAmountMap
18128 
    self.xferBy = xferBy
18129 
    self.xferTxnId = xferTxnId
18130 
    self.xferDate = xferDate
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 1:
18142 
        if ftype == TType.MAP:
18143 
          self.collectedAmountMap = {}
5481 phani.kuma 18144 
          (_ktype397, _vtype398, _size396 ) = iprot.readMapBegin()
18145 
          for _i400 in xrange(_size396):
18146 
            _key401 = iprot.readString();
18147 
            _val402 = iprot.readDouble();
18148 
            self.collectedAmountMap[_key401] = _val402
3956 chandransh 18149 
          iprot.readMapEnd()
18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      elif fid == 2:
18153 
        if ftype == TType.STRING:
18154 
          self.xferBy = iprot.readString();
18155 
        else:
18156 
          iprot.skip(ftype)
18157 
      elif fid == 3:
18158 
        if ftype == TType.STRING:
18159 
          self.xferTxnId = iprot.readString();
18160 
        else:
18161 
          iprot.skip(ftype)
18162 
      elif fid == 4:
18163 
        if ftype == TType.I64:
18164 
          self.xferDate = iprot.readI64();
18165 
        else:
18166 
          iprot.skip(ftype)
18167 
      else:
18168 
        iprot.skip(ftype)
18169 
      iprot.readFieldEnd()
18170 
    iprot.readStructEnd()
18171 
 
18172 
  def write(self, oprot):
18173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18175 
      return
18176 
    oprot.writeStructBegin('reconcileCodCollection_args')
18177 
    if self.collectedAmountMap is not None:
18178 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18179 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5481 phani.kuma 18180 
      for kiter403,viter404 in self.collectedAmountMap.items():
18181 
        oprot.writeString(kiter403)
18182 
        oprot.writeDouble(viter404)
3956 chandransh 18183 
      oprot.writeMapEnd()
18184 
      oprot.writeFieldEnd()
18185 
    if self.xferBy is not None:
18186 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18187 
      oprot.writeString(self.xferBy)
18188 
      oprot.writeFieldEnd()
18189 
    if self.xferTxnId is not None:
18190 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18191 
      oprot.writeString(self.xferTxnId)
18192 
      oprot.writeFieldEnd()
18193 
    if self.xferDate is not None:
18194 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18195 
      oprot.writeI64(self.xferDate)
18196 
      oprot.writeFieldEnd()
18197 
    oprot.writeFieldStop()
18198 
    oprot.writeStructEnd()
18199 
 
18200 
  def validate(self):
18201 
    return
18202 
 
18203 
 
18204 
  def __repr__(self):
18205 
    L = ['%s=%r' % (key, value)
18206 
      for key, value in self.__dict__.iteritems()]
18207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18208 
 
18209 
  def __eq__(self, other):
18210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18211 
 
18212 
  def __ne__(self, other):
18213 
    return not (self == other)
18214 
 
18215 
class reconcileCodCollection_result:
18216 
  """
18217 
  Attributes:
18218 
   - success
18219 
   - ex
18220 
  """
18221 
 
18222 
  thrift_spec = (
18223 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18225 
  )
18226 
 
18227 
  def __init__(self, success=None, ex=None,):
18228 
    self.success = success
18229 
    self.ex = ex
18230 
 
18231 
  def read(self, iprot):
18232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18234 
      return
18235 
    iprot.readStructBegin()
18236 
    while True:
18237 
      (fname, ftype, fid) = iprot.readFieldBegin()
18238 
      if ftype == TType.STOP:
18239 
        break
18240 
      if fid == 0:
18241 
        if ftype == TType.MAP:
18242 
          self.success = {}
5481 phani.kuma 18243 
          (_ktype406, _vtype407, _size405 ) = iprot.readMapBegin()
18244 
          for _i409 in xrange(_size405):
18245 
            _key410 = iprot.readString();
18246 
            _val411 = iprot.readString();
18247 
            self.success[_key410] = _val411
3956 chandransh 18248 
          iprot.readMapEnd()
18249 
        else:
18250 
          iprot.skip(ftype)
18251 
      elif fid == 1:
18252 
        if ftype == TType.STRUCT:
18253 
          self.ex = TransactionServiceException()
18254 
          self.ex.read(iprot)
18255 
        else:
18256 
          iprot.skip(ftype)
18257 
      else:
18258 
        iprot.skip(ftype)
18259 
      iprot.readFieldEnd()
18260 
    iprot.readStructEnd()
18261 
 
18262 
  def write(self, oprot):
18263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18265 
      return
18266 
    oprot.writeStructBegin('reconcileCodCollection_result')
18267 
    if self.success is not None:
18268 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18269 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5481 phani.kuma 18270 
      for kiter412,viter413 in self.success.items():
18271 
        oprot.writeString(kiter412)
18272 
        oprot.writeString(viter413)
3956 chandransh 18273 
      oprot.writeMapEnd()
18274 
      oprot.writeFieldEnd()
18275 
    if self.ex is not None:
18276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18277 
      self.ex.write(oprot)
18278 
      oprot.writeFieldEnd()
18279 
    oprot.writeFieldStop()
18280 
    oprot.writeStructEnd()
18281 
 
18282 
  def validate(self):
18283 
    return
18284 
 
18285 
 
18286 
  def __repr__(self):
18287 
    L = ['%s=%r' % (key, value)
18288 
      for key, value in self.__dict__.iteritems()]
18289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18290 
 
18291 
  def __eq__(self, other):
18292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18293 
 
18294 
  def __ne__(self, other):
18295 
    return not (self == other)
4008 mandeep.dh 18296 
 
18297 
class getTransactionsRequiringExtraProcessing_args:
18298 
  """
18299 
  Attributes:
18300 
   - category
18301 
  """
18302 
 
18303 
  thrift_spec = (
18304 
    None, # 0
18305 
    (1, TType.I32, 'category', None, None, ), # 1
18306 
  )
18307 
 
18308 
  def __init__(self, category=None,):
18309 
    self.category = category
18310 
 
18311 
  def read(self, iprot):
18312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18314 
      return
18315 
    iprot.readStructBegin()
18316 
    while True:
18317 
      (fname, ftype, fid) = iprot.readFieldBegin()
18318 
      if ftype == TType.STOP:
18319 
        break
18320 
      if fid == 1:
18321 
        if ftype == TType.I32:
18322 
          self.category = iprot.readI32();
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18335 
    if self.category is not None:
18336 
      oprot.writeFieldBegin('category', TType.I32, 1)
18337 
      oprot.writeI32(self.category)
18338 
      oprot.writeFieldEnd()
18339 
    oprot.writeFieldStop()
18340 
    oprot.writeStructEnd()
18341 
 
18342 
  def validate(self):
18343 
    return
18344 
 
18345 
 
18346 
  def __repr__(self):
18347 
    L = ['%s=%r' % (key, value)
18348 
      for key, value in self.__dict__.iteritems()]
18349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18350 
 
18351 
  def __eq__(self, other):
18352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18353 
 
18354 
  def __ne__(self, other):
18355 
    return not (self == other)
18356 
 
18357 
class getTransactionsRequiringExtraProcessing_result:
18358 
  """
18359 
  Attributes:
18360 
   - success
18361 
  """
18362 
 
18363 
  thrift_spec = (
18364 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18365 
  )
18366 
 
18367 
  def __init__(self, success=None,):
18368 
    self.success = success
18369 
 
18370 
  def read(self, iprot):
18371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18373 
      return
18374 
    iprot.readStructBegin()
18375 
    while True:
18376 
      (fname, ftype, fid) = iprot.readFieldBegin()
18377 
      if ftype == TType.STOP:
18378 
        break
18379 
      if fid == 0:
18380 
        if ftype == TType.LIST:
18381 
          self.success = []
5481 phani.kuma 18382 
          (_etype417, _size414) = iprot.readListBegin()
18383 
          for _i418 in xrange(_size414):
18384 
            _elem419 = iprot.readI64();
18385 
            self.success.append(_elem419)
4008 mandeep.dh 18386 
          iprot.readListEnd()
18387 
        else:
18388 
          iprot.skip(ftype)
18389 
      else:
18390 
        iprot.skip(ftype)
18391 
      iprot.readFieldEnd()
18392 
    iprot.readStructEnd()
18393 
 
18394 
  def write(self, oprot):
18395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18397 
      return
18398 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18399 
    if self.success is not None:
18400 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18401 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 18402 
      for iter420 in self.success:
18403 
        oprot.writeI64(iter420)
4008 mandeep.dh 18404 
      oprot.writeListEnd()
18405 
      oprot.writeFieldEnd()
18406 
    oprot.writeFieldStop()
18407 
    oprot.writeStructEnd()
18408 
 
18409 
  def validate(self):
18410 
    return
18411 
 
18412 
 
18413 
  def __repr__(self):
18414 
    L = ['%s=%r' % (key, value)
18415 
      for key, value in self.__dict__.iteritems()]
18416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18417 
 
18418 
  def __eq__(self, other):
18419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18420 
 
18421 
  def __ne__(self, other):
18422 
    return not (self == other)
18423 
 
18424 
class markTransactionAsProcessed_args:
18425 
  """
18426 
  Attributes:
18427 
   - transactionId
18428 
   - category
18429 
  """
18430 
 
18431 
  thrift_spec = (
18432 
    None, # 0
18433 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18434 
    (2, TType.I32, 'category', None, None, ), # 2
18435 
  )
18436 
 
18437 
  def __init__(self, transactionId=None, category=None,):
18438 
    self.transactionId = transactionId
18439 
    self.category = category
18440 
 
18441 
  def read(self, iprot):
18442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18444 
      return
18445 
    iprot.readStructBegin()
18446 
    while True:
18447 
      (fname, ftype, fid) = iprot.readFieldBegin()
18448 
      if ftype == TType.STOP:
18449 
        break
18450 
      if fid == 1:
18451 
        if ftype == TType.I64:
18452 
          self.transactionId = iprot.readI64();
18453 
        else:
18454 
          iprot.skip(ftype)
18455 
      elif fid == 2:
18456 
        if ftype == TType.I32:
18457 
          self.category = iprot.readI32();
18458 
        else:
18459 
          iprot.skip(ftype)
18460 
      else:
18461 
        iprot.skip(ftype)
18462 
      iprot.readFieldEnd()
18463 
    iprot.readStructEnd()
18464 
 
18465 
  def write(self, oprot):
18466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18468 
      return
18469 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18470 
    if self.transactionId is not None:
18471 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18472 
      oprot.writeI64(self.transactionId)
18473 
      oprot.writeFieldEnd()
18474 
    if self.category is not None:
18475 
      oprot.writeFieldBegin('category', TType.I32, 2)
18476 
      oprot.writeI32(self.category)
18477 
      oprot.writeFieldEnd()
18478 
    oprot.writeFieldStop()
18479 
    oprot.writeStructEnd()
18480 
 
18481 
  def validate(self):
18482 
    return
18483 
 
18484 
 
18485 
  def __repr__(self):
18486 
    L = ['%s=%r' % (key, value)
18487 
      for key, value in self.__dict__.iteritems()]
18488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18489 
 
18490 
  def __eq__(self, other):
18491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18492 
 
18493 
  def __ne__(self, other):
18494 
    return not (self == other)
18495 
 
18496 
class markTransactionAsProcessed_result:
18497 
 
18498 
  thrift_spec = (
18499 
  )
18500 
 
18501 
  def read(self, iprot):
18502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18504 
      return
18505 
    iprot.readStructBegin()
18506 
    while True:
18507 
      (fname, ftype, fid) = iprot.readFieldBegin()
18508 
      if ftype == TType.STOP:
18509 
        break
18510 
      else:
18511 
        iprot.skip(ftype)
18512 
      iprot.readFieldEnd()
18513 
    iprot.readStructEnd()
18514 
 
18515 
  def write(self, oprot):
18516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18518 
      return
18519 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18520 
    oprot.writeFieldStop()
18521 
    oprot.writeStructEnd()
18522 
 
18523 
  def validate(self):
18524 
    return
18525 
 
18526 
 
18527 
  def __repr__(self):
18528 
    L = ['%s=%r' % (key, value)
18529 
      for key, value in self.__dict__.iteritems()]
18530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18531 
 
18532 
  def __eq__(self, other):
18533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18534 
 
18535 
  def __ne__(self, other):
18536 
    return not (self == other)
4018 chandransh 18537 
 
18538 
class getItemWiseRiskyOrdersCount_args:
18539 
 
18540 
  thrift_spec = (
18541 
  )
18542 
 
18543 
  def read(self, iprot):
18544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18546 
      return
18547 
    iprot.readStructBegin()
18548 
    while True:
18549 
      (fname, ftype, fid) = iprot.readFieldBegin()
18550 
      if ftype == TType.STOP:
18551 
        break
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18562 
    oprot.writeFieldStop()
18563 
    oprot.writeStructEnd()
18564 
 
18565 
  def validate(self):
18566 
    return
18567 
 
18568 
 
18569 
  def __repr__(self):
18570 
    L = ['%s=%r' % (key, value)
18571 
      for key, value in self.__dict__.iteritems()]
18572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18573 
 
18574 
  def __eq__(self, other):
18575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18576 
 
18577 
  def __ne__(self, other):
18578 
    return not (self == other)
18579 
 
18580 
class getItemWiseRiskyOrdersCount_result:
18581 
  """
18582 
  Attributes:
18583 
   - success
18584 
  """
18585 
 
18586 
  thrift_spec = (
18587 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18588 
  )
18589 
 
18590 
  def __init__(self, success=None,):
18591 
    self.success = success
18592 
 
18593 
  def read(self, iprot):
18594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18596 
      return
18597 
    iprot.readStructBegin()
18598 
    while True:
18599 
      (fname, ftype, fid) = iprot.readFieldBegin()
18600 
      if ftype == TType.STOP:
18601 
        break
18602 
      if fid == 0:
18603 
        if ftype == TType.MAP:
18604 
          self.success = {}
5481 phani.kuma 18605 
          (_ktype422, _vtype423, _size421 ) = iprot.readMapBegin()
18606 
          for _i425 in xrange(_size421):
18607 
            _key426 = iprot.readI64();
18608 
            _val427 = iprot.readI64();
18609 
            self.success[_key426] = _val427
4018 chandransh 18610 
          iprot.readMapEnd()
18611 
        else:
18612 
          iprot.skip(ftype)
18613 
      else:
18614 
        iprot.skip(ftype)
18615 
      iprot.readFieldEnd()
18616 
    iprot.readStructEnd()
18617 
 
18618 
  def write(self, oprot):
18619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18621 
      return
18622 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18623 
    if self.success is not None:
18624 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18625 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 18626 
      for kiter428,viter429 in self.success.items():
18627 
        oprot.writeI64(kiter428)
18628 
        oprot.writeI64(viter429)
4018 chandransh 18629 
      oprot.writeMapEnd()
18630 
      oprot.writeFieldEnd()
18631 
    oprot.writeFieldStop()
18632 
    oprot.writeStructEnd()
18633 
 
18634 
  def validate(self):
18635 
    return
18636 
 
18637 
 
18638 
  def __repr__(self):
18639 
    L = ['%s=%r' % (key, value)
18640 
      for key, value in self.__dict__.iteritems()]
18641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18642 
 
18643 
  def __eq__(self, other):
18644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18645 
 
18646 
  def __ne__(self, other):
18647 
    return not (self == other)
4247 rajveer 18648 
 
4295 varun.gupt 18649 
class getOrdersForItemIds_args:
18650 
  """
18651 
  Attributes:
18652 
   - itemIds
18653 
  """
18654 
 
18655 
  thrift_spec = (
18656 
    None, # 0
18657 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18658 
  )
18659 
 
18660 
  def __init__(self, itemIds=None,):
18661 
    self.itemIds = itemIds
18662 
 
18663 
  def read(self, iprot):
18664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18666 
      return
18667 
    iprot.readStructBegin()
18668 
    while True:
18669 
      (fname, ftype, fid) = iprot.readFieldBegin()
18670 
      if ftype == TType.STOP:
18671 
        break
18672 
      if fid == 1:
18673 
        if ftype == TType.LIST:
18674 
          self.itemIds = []
5481 phani.kuma 18675 
          (_etype433, _size430) = iprot.readListBegin()
18676 
          for _i434 in xrange(_size430):
18677 
            _elem435 = iprot.readI64();
18678 
            self.itemIds.append(_elem435)
4295 varun.gupt 18679 
          iprot.readListEnd()
18680 
        else:
18681 
          iprot.skip(ftype)
18682 
      else:
18683 
        iprot.skip(ftype)
18684 
      iprot.readFieldEnd()
18685 
    iprot.readStructEnd()
18686 
 
18687 
  def write(self, oprot):
18688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18690 
      return
18691 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18692 
    if self.itemIds is not None:
18693 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18694 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5481 phani.kuma 18695 
      for iter436 in self.itemIds:
18696 
        oprot.writeI64(iter436)
4295 varun.gupt 18697 
      oprot.writeListEnd()
18698 
      oprot.writeFieldEnd()
18699 
    oprot.writeFieldStop()
18700 
    oprot.writeStructEnd()
18701 
 
18702 
  def validate(self):
18703 
    return
18704 
 
18705 
 
18706 
  def __repr__(self):
18707 
    L = ['%s=%r' % (key, value)
18708 
      for key, value in self.__dict__.iteritems()]
18709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18710 
 
18711 
  def __eq__(self, other):
18712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18713 
 
18714 
  def __ne__(self, other):
18715 
    return not (self == other)
18716 
 
18717 
class getOrdersForItemIds_result:
18718 
  """
18719 
  Attributes:
18720 
   - success
18721 
  """
18722 
 
18723 
  thrift_spec = (
18724 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18725 
  )
18726 
 
18727 
  def __init__(self, success=None,):
18728 
    self.success = success
18729 
 
18730 
  def read(self, iprot):
18731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18733 
      return
18734 
    iprot.readStructBegin()
18735 
    while True:
18736 
      (fname, ftype, fid) = iprot.readFieldBegin()
18737 
      if ftype == TType.STOP:
18738 
        break
18739 
      if fid == 0:
18740 
        if ftype == TType.LIST:
18741 
          self.success = []
5481 phani.kuma 18742 
          (_etype440, _size437) = iprot.readListBegin()
18743 
          for _i441 in xrange(_size437):
18744 
            _elem442 = Order()
18745 
            _elem442.read(iprot)
18746 
            self.success.append(_elem442)
4295 varun.gupt 18747 
          iprot.readListEnd()
18748 
        else:
18749 
          iprot.skip(ftype)
18750 
      else:
18751 
        iprot.skip(ftype)
18752 
      iprot.readFieldEnd()
18753 
    iprot.readStructEnd()
18754 
 
18755 
  def write(self, oprot):
18756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18758 
      return
18759 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18760 
    if self.success is not None:
18761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18762 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 18763 
      for iter443 in self.success:
18764 
        iter443.write(oprot)
4295 varun.gupt 18765 
      oprot.writeListEnd()
18766 
      oprot.writeFieldEnd()
18767 
    oprot.writeFieldStop()
18768 
    oprot.writeStructEnd()
18769 
 
18770 
  def validate(self):
18771 
    return
18772 
 
18773 
 
18774 
  def __repr__(self):
18775 
    L = ['%s=%r' % (key, value)
18776 
      for key, value in self.__dict__.iteritems()]
18777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18778 
 
18779 
  def __eq__(self, other):
18780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18781 
 
18782 
  def __ne__(self, other):
18783 
    return not (self == other)
18784 
 
4247 rajveer 18785 
class markOrderCancellationRequestReceived_args:
18786 
  """
18787 
  Attributes:
18788 
   - orderId
18789 
  """
18790 
 
18791 
  thrift_spec = (
18792 
    None, # 0
18793 
    (1, TType.I64, 'orderId', None, None, ), # 1
18794 
  )
18795 
 
18796 
  def __init__(self, orderId=None,):
18797 
    self.orderId = orderId
18798 
 
18799 
  def read(self, iprot):
18800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18802 
      return
18803 
    iprot.readStructBegin()
18804 
    while True:
18805 
      (fname, ftype, fid) = iprot.readFieldBegin()
18806 
      if ftype == TType.STOP:
18807 
        break
18808 
      if fid == 1:
18809 
        if ftype == TType.I64:
18810 
          self.orderId = iprot.readI64();
18811 
        else:
18812 
          iprot.skip(ftype)
18813 
      else:
18814 
        iprot.skip(ftype)
18815 
      iprot.readFieldEnd()
18816 
    iprot.readStructEnd()
18817 
 
18818 
  def write(self, oprot):
18819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18821 
      return
18822 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18823 
    if self.orderId is not None:
18824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18825 
      oprot.writeI64(self.orderId)
18826 
      oprot.writeFieldEnd()
18827 
    oprot.writeFieldStop()
18828 
    oprot.writeStructEnd()
18829 
 
18830 
  def validate(self):
18831 
    return
18832 
 
18833 
 
18834 
  def __repr__(self):
18835 
    L = ['%s=%r' % (key, value)
18836 
      for key, value in self.__dict__.iteritems()]
18837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18838 
 
18839 
  def __eq__(self, other):
18840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18841 
 
18842 
  def __ne__(self, other):
18843 
    return not (self == other)
18844 
 
18845 
class markOrderCancellationRequestReceived_result:
18846 
  """
18847 
  Attributes:
18848 
   - ex
18849 
  """
18850 
 
18851 
  thrift_spec = (
18852 
    None, # 0
18853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18854 
  )
18855 
 
18856 
  def __init__(self, ex=None,):
18857 
    self.ex = ex
18858 
 
18859 
  def read(self, iprot):
18860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18862 
      return
18863 
    iprot.readStructBegin()
18864 
    while True:
18865 
      (fname, ftype, fid) = iprot.readFieldBegin()
18866 
      if ftype == TType.STOP:
18867 
        break
18868 
      if fid == 1:
18869 
        if ftype == TType.STRUCT:
18870 
          self.ex = TransactionServiceException()
18871 
          self.ex.read(iprot)
18872 
        else:
18873 
          iprot.skip(ftype)
18874 
      else:
18875 
        iprot.skip(ftype)
18876 
      iprot.readFieldEnd()
18877 
    iprot.readStructEnd()
18878 
 
18879 
  def write(self, oprot):
18880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18882 
      return
18883 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18884 
    if self.ex is not None:
18885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18886 
      self.ex.write(oprot)
18887 
      oprot.writeFieldEnd()
18888 
    oprot.writeFieldStop()
18889 
    oprot.writeStructEnd()
18890 
 
18891 
  def validate(self):
18892 
    return
18893 
 
18894 
 
18895 
  def __repr__(self):
18896 
    L = ['%s=%r' % (key, value)
18897 
      for key, value in self.__dict__.iteritems()]
18898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18899 
 
18900 
  def __eq__(self, other):
18901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18902 
 
18903 
  def __ne__(self, other):
18904 
    return not (self == other)
18905 
 
18906 
class markOrderCancellationRequestConfirmed_args:
18907 
  """
18908 
  Attributes:
18909 
   - orderId
18910 
  """
18911 
 
18912 
  thrift_spec = (
18913 
    None, # 0
18914 
    (1, TType.I64, 'orderId', None, None, ), # 1
18915 
  )
18916 
 
18917 
  def __init__(self, orderId=None,):
18918 
    self.orderId = orderId
18919 
 
18920 
  def read(self, iprot):
18921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18923 
      return
18924 
    iprot.readStructBegin()
18925 
    while True:
18926 
      (fname, ftype, fid) = iprot.readFieldBegin()
18927 
      if ftype == TType.STOP:
18928 
        break
18929 
      if fid == 1:
18930 
        if ftype == TType.I64:
18931 
          self.orderId = iprot.readI64();
18932 
        else:
18933 
          iprot.skip(ftype)
18934 
      else:
18935 
        iprot.skip(ftype)
18936 
      iprot.readFieldEnd()
18937 
    iprot.readStructEnd()
18938 
 
18939 
  def write(self, oprot):
18940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18942 
      return
18943 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18944 
    if self.orderId is not None:
18945 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18946 
      oprot.writeI64(self.orderId)
18947 
      oprot.writeFieldEnd()
18948 
    oprot.writeFieldStop()
18949 
    oprot.writeStructEnd()
18950 
 
18951 
  def validate(self):
18952 
    return
18953 
 
18954 
 
18955 
  def __repr__(self):
18956 
    L = ['%s=%r' % (key, value)
18957 
      for key, value in self.__dict__.iteritems()]
18958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18959 
 
18960 
  def __eq__(self, other):
18961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18962 
 
18963 
  def __ne__(self, other):
18964 
    return not (self == other)
18965 
 
18966 
class markOrderCancellationRequestConfirmed_result:
18967 
  """
18968 
  Attributes:
18969 
   - ex
18970 
  """
18971 
 
18972 
  thrift_spec = (
18973 
    None, # 0
18974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18975 
  )
18976 
 
18977 
  def __init__(self, ex=None,):
18978 
    self.ex = ex
18979 
 
18980 
  def read(self, iprot):
18981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18983 
      return
18984 
    iprot.readStructBegin()
18985 
    while True:
18986 
      (fname, ftype, fid) = iprot.readFieldBegin()
18987 
      if ftype == TType.STOP:
18988 
        break
18989 
      if fid == 1:
18990 
        if ftype == TType.STRUCT:
18991 
          self.ex = TransactionServiceException()
18992 
          self.ex.read(iprot)
18993 
        else:
18994 
          iprot.skip(ftype)
18995 
      else:
18996 
        iprot.skip(ftype)
18997 
      iprot.readFieldEnd()
18998 
    iprot.readStructEnd()
18999 
 
19000 
  def write(self, oprot):
19001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19003 
      return
19004 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19005 
    if self.ex is not None:
19006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19007 
      self.ex.write(oprot)
19008 
      oprot.writeFieldEnd()
19009 
    oprot.writeFieldStop()
19010 
    oprot.writeStructEnd()
19011 
 
19012 
  def validate(self):
19013 
    return
19014 
 
19015 
 
19016 
  def __repr__(self):
19017 
    L = ['%s=%r' % (key, value)
19018 
      for key, value in self.__dict__.iteritems()]
19019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19020 
 
19021 
  def __eq__(self, other):
19022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19023 
 
19024 
  def __ne__(self, other):
19025 
    return not (self == other)
19026 
 
19027 
class markOrderCancellationRequestDenied_args:
19028 
  """
19029 
  Attributes:
19030 
   - orderId
19031 
  """
19032 
 
19033 
  thrift_spec = (
19034 
    None, # 0
19035 
    (1, TType.I64, 'orderId', None, None, ), # 1
19036 
  )
19037 
 
19038 
  def __init__(self, orderId=None,):
19039 
    self.orderId = orderId
19040 
 
19041 
  def read(self, iprot):
19042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19044 
      return
19045 
    iprot.readStructBegin()
19046 
    while True:
19047 
      (fname, ftype, fid) = iprot.readFieldBegin()
19048 
      if ftype == TType.STOP:
19049 
        break
19050 
      if fid == 1:
19051 
        if ftype == TType.I64:
19052 
          self.orderId = iprot.readI64();
19053 
        else:
19054 
          iprot.skip(ftype)
19055 
      else:
19056 
        iprot.skip(ftype)
19057 
      iprot.readFieldEnd()
19058 
    iprot.readStructEnd()
19059 
 
19060 
  def write(self, oprot):
19061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19063 
      return
19064 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19065 
    if self.orderId is not None:
19066 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19067 
      oprot.writeI64(self.orderId)
19068 
      oprot.writeFieldEnd()
19069 
    oprot.writeFieldStop()
19070 
    oprot.writeStructEnd()
19071 
 
19072 
  def validate(self):
19073 
    return
19074 
 
19075 
 
19076 
  def __repr__(self):
19077 
    L = ['%s=%r' % (key, value)
19078 
      for key, value in self.__dict__.iteritems()]
19079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19080 
 
19081 
  def __eq__(self, other):
19082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19083 
 
19084 
  def __ne__(self, other):
19085 
    return not (self == other)
19086 
 
19087 
class markOrderCancellationRequestDenied_result:
19088 
  """
19089 
  Attributes:
19090 
   - ex
19091 
  """
19092 
 
19093 
  thrift_spec = (
19094 
    None, # 0
19095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19096 
  )
19097 
 
19098 
  def __init__(self, ex=None,):
19099 
    self.ex = ex
19100 
 
19101 
  def read(self, iprot):
19102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19104 
      return
19105 
    iprot.readStructBegin()
19106 
    while True:
19107 
      (fname, ftype, fid) = iprot.readFieldBegin()
19108 
      if ftype == TType.STOP:
19109 
        break
19110 
      if fid == 1:
19111 
        if ftype == TType.STRUCT:
19112 
          self.ex = TransactionServiceException()
19113 
          self.ex.read(iprot)
19114 
        else:
19115 
          iprot.skip(ftype)
19116 
      else:
19117 
        iprot.skip(ftype)
19118 
      iprot.readFieldEnd()
19119 
    iprot.readStructEnd()
19120 
 
19121 
  def write(self, oprot):
19122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19124 
      return
19125 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19126 
    if self.ex is not None:
19127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19128 
      self.ex.write(oprot)
19129 
      oprot.writeFieldEnd()
19130 
    oprot.writeFieldStop()
19131 
    oprot.writeStructEnd()
19132 
 
19133 
  def validate(self):
19134 
    return
19135 
 
19136 
 
19137 
  def __repr__(self):
19138 
    L = ['%s=%r' % (key, value)
19139 
      for key, value in self.__dict__.iteritems()]
19140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19141 
 
19142 
  def __eq__(self, other):
19143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19144 
 
19145 
  def __ne__(self, other):
19146 
    return not (self == other)
19147 
 
4258 rajveer 19148 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19149 
  """
19150 
  Attributes:
4258 rajveer 19151 
   - transactionId
4247 rajveer 19152 
  """
19153 
 
19154 
  thrift_spec = (
19155 
    None, # 0
4258 rajveer 19156 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19157 
  )
19158 
 
4258 rajveer 19159 
  def __init__(self, transactionId=None,):
19160 
    self.transactionId = transactionId
4247 rajveer 19161 
 
19162 
  def read(self, iprot):
19163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19165 
      return
19166 
    iprot.readStructBegin()
19167 
    while True:
19168 
      (fname, ftype, fid) = iprot.readFieldBegin()
19169 
      if ftype == TType.STOP:
19170 
        break
19171 
      if fid == 1:
19172 
        if ftype == TType.I64:
4258 rajveer 19173 
          self.transactionId = iprot.readI64();
4247 rajveer 19174 
        else:
19175 
          iprot.skip(ftype)
19176 
      else:
19177 
        iprot.skip(ftype)
19178 
      iprot.readFieldEnd()
19179 
    iprot.readStructEnd()
19180 
 
19181 
  def write(self, oprot):
19182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19184 
      return
4258 rajveer 19185 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19186 
    if self.transactionId is not None:
19187 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19188 
      oprot.writeI64(self.transactionId)
4247 rajveer 19189 
      oprot.writeFieldEnd()
19190 
    oprot.writeFieldStop()
19191 
    oprot.writeStructEnd()
19192 
 
19193 
  def validate(self):
19194 
    return
19195 
 
19196 
 
19197 
  def __repr__(self):
19198 
    L = ['%s=%r' % (key, value)
19199 
      for key, value in self.__dict__.iteritems()]
19200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19201 
 
19202 
  def __eq__(self, other):
19203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19204 
 
19205 
  def __ne__(self, other):
19206 
    return not (self == other)
19207 
 
4258 rajveer 19208 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19209 
  """
19210 
  Attributes:
19211 
   - ex
19212 
  """
19213 
 
19214 
  thrift_spec = (
19215 
    None, # 0
19216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19217 
  )
19218 
 
19219 
  def __init__(self, ex=None,):
19220 
    self.ex = ex
19221 
 
19222 
  def read(self, iprot):
19223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19225 
      return
19226 
    iprot.readStructBegin()
19227 
    while True:
19228 
      (fname, ftype, fid) = iprot.readFieldBegin()
19229 
      if ftype == TType.STOP:
19230 
        break
19231 
      if fid == 1:
19232 
        if ftype == TType.STRUCT:
19233 
          self.ex = TransactionServiceException()
19234 
          self.ex.read(iprot)
19235 
        else:
19236 
          iprot.skip(ftype)
19237 
      else:
19238 
        iprot.skip(ftype)
19239 
      iprot.readFieldEnd()
19240 
    iprot.readStructEnd()
19241 
 
19242 
  def write(self, oprot):
19243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19245 
      return
4258 rajveer 19246 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19247 
    if self.ex is not None:
19248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19249 
      self.ex.write(oprot)
19250 
      oprot.writeFieldEnd()
19251 
    oprot.writeFieldStop()
19252 
    oprot.writeStructEnd()
19253 
 
19254 
  def validate(self):
19255 
    return
19256 
 
19257 
 
19258 
  def __repr__(self):
19259 
    L = ['%s=%r' % (key, value)
19260 
      for key, value in self.__dict__.iteritems()]
19261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19262 
 
19263 
  def __eq__(self, other):
19264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19265 
 
19266 
  def __ne__(self, other):
19267 
    return not (self == other)
4259 anupam.sin 19268 
 
19269 
class refundTransaction_args:
19270 
  """
19271 
  Attributes:
19272 
   - transactionId
19273 
   - refundedBy
19274 
   - reason
19275 
  """
19276 
 
19277 
  thrift_spec = (
19278 
    None, # 0
19279 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19280 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19281 
    (3, TType.STRING, 'reason', None, None, ), # 3
19282 
  )
19283 
 
19284 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19285 
    self.transactionId = transactionId
19286 
    self.refundedBy = refundedBy
19287 
    self.reason = reason
19288 
 
19289 
  def read(self, iprot):
19290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19292 
      return
19293 
    iprot.readStructBegin()
19294 
    while True:
19295 
      (fname, ftype, fid) = iprot.readFieldBegin()
19296 
      if ftype == TType.STOP:
19297 
        break
19298 
      if fid == 1:
19299 
        if ftype == TType.I64:
19300 
          self.transactionId = iprot.readI64();
19301 
        else:
19302 
          iprot.skip(ftype)
19303 
      elif fid == 2:
19304 
        if ftype == TType.STRING:
19305 
          self.refundedBy = iprot.readString();
19306 
        else:
19307 
          iprot.skip(ftype)
19308 
      elif fid == 3:
19309 
        if ftype == TType.STRING:
19310 
          self.reason = iprot.readString();
19311 
        else:
19312 
          iprot.skip(ftype)
19313 
      else:
19314 
        iprot.skip(ftype)
19315 
      iprot.readFieldEnd()
19316 
    iprot.readStructEnd()
19317 
 
19318 
  def write(self, oprot):
19319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19321 
      return
19322 
    oprot.writeStructBegin('refundTransaction_args')
19323 
    if self.transactionId is not None:
19324 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19325 
      oprot.writeI64(self.transactionId)
19326 
      oprot.writeFieldEnd()
19327 
    if self.refundedBy is not None:
19328 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19329 
      oprot.writeString(self.refundedBy)
19330 
      oprot.writeFieldEnd()
19331 
    if self.reason is not None:
19332 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19333 
      oprot.writeString(self.reason)
19334 
      oprot.writeFieldEnd()
19335 
    oprot.writeFieldStop()
19336 
    oprot.writeStructEnd()
19337 
 
19338 
  def validate(self):
19339 
    return
19340 
 
19341 
 
19342 
  def __repr__(self):
19343 
    L = ['%s=%r' % (key, value)
19344 
      for key, value in self.__dict__.iteritems()]
19345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19346 
 
19347 
  def __eq__(self, other):
19348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19349 
 
19350 
  def __ne__(self, other):
19351 
    return not (self == other)
19352 
 
19353 
class refundTransaction_result:
19354 
  """
19355 
  Attributes:
19356 
   - ex
19357 
  """
19358 
 
19359 
  thrift_spec = (
19360 
    None, # 0
19361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19362 
  )
19363 
 
19364 
  def __init__(self, ex=None,):
19365 
    self.ex = ex
19366 
 
19367 
  def read(self, iprot):
19368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19370 
      return
19371 
    iprot.readStructBegin()
19372 
    while True:
19373 
      (fname, ftype, fid) = iprot.readFieldBegin()
19374 
      if ftype == TType.STOP:
19375 
        break
19376 
      if fid == 1:
19377 
        if ftype == TType.STRUCT:
19378 
          self.ex = TransactionServiceException()
19379 
          self.ex.read(iprot)
19380 
        else:
19381 
          iprot.skip(ftype)
19382 
      else:
19383 
        iprot.skip(ftype)
19384 
      iprot.readFieldEnd()
19385 
    iprot.readStructEnd()
19386 
 
19387 
  def write(self, oprot):
19388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19390 
      return
19391 
    oprot.writeStructBegin('refundTransaction_result')
19392 
    if self.ex is not None:
19393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19394 
      self.ex.write(oprot)
19395 
      oprot.writeFieldEnd()
19396 
    oprot.writeFieldStop()
19397 
    oprot.writeStructEnd()
19398 
 
19399 
  def validate(self):
19400 
    return
19401 
 
19402 
 
19403 
  def __repr__(self):
19404 
    L = ['%s=%r' % (key, value)
19405 
      for key, value in self.__dict__.iteritems()]
19406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19407 
 
19408 
  def __eq__(self, other):
19409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19410 
 
19411 
  def __ne__(self, other):
19412 
    return not (self == other)
4285 rajveer 19413 
 
4324 mandeep.dh 19414 
class updateShipmentAddress_args:
19415 
  """
19416 
  Attributes:
19417 
   - orderId
19418 
   - addressId
19419 
  """
19420 
 
19421 
  thrift_spec = (
19422 
    None, # 0
19423 
    (1, TType.I64, 'orderId', None, None, ), # 1
19424 
    (2, TType.I64, 'addressId', None, None, ), # 2
19425 
  )
19426 
 
19427 
  def __init__(self, orderId=None, addressId=None,):
19428 
    self.orderId = orderId
19429 
    self.addressId = addressId
19430 
 
19431 
  def read(self, iprot):
19432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19434 
      return
19435 
    iprot.readStructBegin()
19436 
    while True:
19437 
      (fname, ftype, fid) = iprot.readFieldBegin()
19438 
      if ftype == TType.STOP:
19439 
        break
19440 
      if fid == 1:
19441 
        if ftype == TType.I64:
19442 
          self.orderId = iprot.readI64();
19443 
        else:
19444 
          iprot.skip(ftype)
19445 
      elif fid == 2:
19446 
        if ftype == TType.I64:
19447 
          self.addressId = iprot.readI64();
19448 
        else:
19449 
          iprot.skip(ftype)
19450 
      else:
19451 
        iprot.skip(ftype)
19452 
      iprot.readFieldEnd()
19453 
    iprot.readStructEnd()
19454 
 
19455 
  def write(self, oprot):
19456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19458 
      return
19459 
    oprot.writeStructBegin('updateShipmentAddress_args')
19460 
    if self.orderId is not None:
19461 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19462 
      oprot.writeI64(self.orderId)
19463 
      oprot.writeFieldEnd()
19464 
    if self.addressId is not None:
19465 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19466 
      oprot.writeI64(self.addressId)
19467 
      oprot.writeFieldEnd()
19468 
    oprot.writeFieldStop()
19469 
    oprot.writeStructEnd()
19470 
 
19471 
  def validate(self):
19472 
    return
19473 
 
19474 
 
19475 
  def __repr__(self):
19476 
    L = ['%s=%r' % (key, value)
19477 
      for key, value in self.__dict__.iteritems()]
19478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19479 
 
19480 
  def __eq__(self, other):
19481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19482 
 
19483 
  def __ne__(self, other):
19484 
    return not (self == other)
19485 
 
19486 
class updateShipmentAddress_result:
19487 
  """
19488 
  Attributes:
19489 
   - ex
19490 
  """
19491 
 
19492 
  thrift_spec = (
19493 
    None, # 0
19494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19495 
  )
19496 
 
19497 
  def __init__(self, ex=None,):
19498 
    self.ex = ex
19499 
 
19500 
  def read(self, iprot):
19501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19503 
      return
19504 
    iprot.readStructBegin()
19505 
    while True:
19506 
      (fname, ftype, fid) = iprot.readFieldBegin()
19507 
      if ftype == TType.STOP:
19508 
        break
19509 
      if fid == 1:
19510 
        if ftype == TType.STRUCT:
19511 
          self.ex = TransactionServiceException()
19512 
          self.ex.read(iprot)
19513 
        else:
19514 
          iprot.skip(ftype)
19515 
      else:
19516 
        iprot.skip(ftype)
19517 
      iprot.readFieldEnd()
19518 
    iprot.readStructEnd()
19519 
 
19520 
  def write(self, oprot):
19521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19523 
      return
19524 
    oprot.writeStructBegin('updateShipmentAddress_result')
19525 
    if self.ex is not None:
19526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19527 
      self.ex.write(oprot)
19528 
      oprot.writeFieldEnd()
19529 
    oprot.writeFieldStop()
19530 
    oprot.writeStructEnd()
19531 
 
19532 
  def validate(self):
19533 
    return
19534 
 
19535 
 
19536 
  def __repr__(self):
19537 
    L = ['%s=%r' % (key, value)
19538 
      for key, value in self.__dict__.iteritems()]
19539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19540 
 
19541 
  def __eq__(self, other):
19542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19543 
 
19544 
  def __ne__(self, other):
19545 
    return not (self == other)
19546 
 
4285 rajveer 19547 
class acceptOrdersForItemId_args:
19548 
  """
19549 
  Attributes:
19550 
   - itemId
19551 
   - inventory
19552 
  """
19553 
 
19554 
  thrift_spec = (
19555 
    None, # 0
19556 
    (1, TType.I64, 'itemId', None, None, ), # 1
19557 
    (2, TType.I64, 'inventory', None, None, ), # 2
19558 
  )
19559 
 
19560 
  def __init__(self, itemId=None, inventory=None,):
19561 
    self.itemId = itemId
19562 
    self.inventory = inventory
19563 
 
19564 
  def read(self, iprot):
19565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19567 
      return
19568 
    iprot.readStructBegin()
19569 
    while True:
19570 
      (fname, ftype, fid) = iprot.readFieldBegin()
19571 
      if ftype == TType.STOP:
19572 
        break
19573 
      if fid == 1:
19574 
        if ftype == TType.I64:
19575 
          self.itemId = iprot.readI64();
19576 
        else:
19577 
          iprot.skip(ftype)
19578 
      elif fid == 2:
19579 
        if ftype == TType.I64:
19580 
          self.inventory = iprot.readI64();
19581 
        else:
19582 
          iprot.skip(ftype)
19583 
      else:
19584 
        iprot.skip(ftype)
19585 
      iprot.readFieldEnd()
19586 
    iprot.readStructEnd()
19587 
 
19588 
  def write(self, oprot):
19589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19591 
      return
19592 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19593 
    if self.itemId is not None:
19594 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19595 
      oprot.writeI64(self.itemId)
19596 
      oprot.writeFieldEnd()
19597 
    if self.inventory is not None:
19598 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19599 
      oprot.writeI64(self.inventory)
19600 
      oprot.writeFieldEnd()
19601 
    oprot.writeFieldStop()
19602 
    oprot.writeStructEnd()
19603 
 
19604 
  def validate(self):
19605 
    return
19606 
 
19607 
 
19608 
  def __repr__(self):
19609 
    L = ['%s=%r' % (key, value)
19610 
      for key, value in self.__dict__.iteritems()]
19611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19612 
 
19613 
  def __eq__(self, other):
19614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19615 
 
19616 
  def __ne__(self, other):
19617 
    return not (self == other)
19618 
 
19619 
class acceptOrdersForItemId_result:
19620 
  """
19621 
  Attributes:
19622 
   - success
19623 
   - ex
19624 
  """
19625 
 
19626 
  thrift_spec = (
19627 
    (0, TType.BOOL, 'success', None, None, ), # 0
19628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19629 
  )
19630 
 
19631 
  def __init__(self, success=None, ex=None,):
19632 
    self.success = success
19633 
    self.ex = ex
19634 
 
19635 
  def read(self, iprot):
19636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19638 
      return
19639 
    iprot.readStructBegin()
19640 
    while True:
19641 
      (fname, ftype, fid) = iprot.readFieldBegin()
19642 
      if ftype == TType.STOP:
19643 
        break
19644 
      if fid == 0:
19645 
        if ftype == TType.BOOL:
19646 
          self.success = iprot.readBool();
19647 
        else:
19648 
          iprot.skip(ftype)
19649 
      elif fid == 1:
19650 
        if ftype == TType.STRUCT:
19651 
          self.ex = TransactionServiceException()
19652 
          self.ex.read(iprot)
19653 
        else:
19654 
          iprot.skip(ftype)
19655 
      else:
19656 
        iprot.skip(ftype)
19657 
      iprot.readFieldEnd()
19658 
    iprot.readStructEnd()
19659 
 
19660 
  def write(self, oprot):
19661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19663 
      return
19664 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
19665 
    if self.success is not None:
19666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19667 
      oprot.writeBool(self.success)
19668 
      oprot.writeFieldEnd()
19669 
    if self.ex is not None:
19670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19671 
      self.ex.write(oprot)
19672 
      oprot.writeFieldEnd()
19673 
    oprot.writeFieldStop()
19674 
    oprot.writeStructEnd()
19675 
 
19676 
  def validate(self):
19677 
    return
19678 
 
19679 
 
19680 
  def __repr__(self):
19681 
    L = ['%s=%r' % (key, value)
19682 
      for key, value in self.__dict__.iteritems()]
19683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19684 
 
19685 
  def __eq__(self, other):
19686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19687 
 
19688 
  def __ne__(self, other):
19689 
    return not (self == other)
4303 rajveer 19690 
 
19691 
class markOrdersAsPORaised_args:
19692 
  """
19693 
  Attributes:
19694 
   - vendorId
19695 
   - itemId
19696 
   - quantity
19697 
   - estimate
4369 rajveer 19698 
   - isReminder
4303 rajveer 19699 
  """
19700 
 
19701 
  thrift_spec = (
19702 
    None, # 0
19703 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19704 
    (2, TType.I64, 'itemId', None, None, ), # 2
19705 
    (3, TType.I64, 'quantity', None, None, ), # 3
19706 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19707 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19708 
  )
19709 
 
4369 rajveer 19710 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19711 
    self.vendorId = vendorId
19712 
    self.itemId = itemId
19713 
    self.quantity = quantity
19714 
    self.estimate = estimate
4369 rajveer 19715 
    self.isReminder = isReminder
4303 rajveer 19716 
 
19717 
  def read(self, iprot):
19718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19720 
      return
19721 
    iprot.readStructBegin()
19722 
    while True:
19723 
      (fname, ftype, fid) = iprot.readFieldBegin()
19724 
      if ftype == TType.STOP:
19725 
        break
19726 
      if fid == 1:
19727 
        if ftype == TType.I64:
19728 
          self.vendorId = iprot.readI64();
19729 
        else:
19730 
          iprot.skip(ftype)
19731 
      elif fid == 2:
19732 
        if ftype == TType.I64:
19733 
          self.itemId = iprot.readI64();
19734 
        else:
19735 
          iprot.skip(ftype)
19736 
      elif fid == 3:
19737 
        if ftype == TType.I64:
19738 
          self.quantity = iprot.readI64();
19739 
        else:
19740 
          iprot.skip(ftype)
19741 
      elif fid == 4:
19742 
        if ftype == TType.I64:
19743 
          self.estimate = iprot.readI64();
19744 
        else:
19745 
          iprot.skip(ftype)
4369 rajveer 19746 
      elif fid == 5:
19747 
        if ftype == TType.BOOL:
19748 
          self.isReminder = iprot.readBool();
19749 
        else:
19750 
          iprot.skip(ftype)
4303 rajveer 19751 
      else:
19752 
        iprot.skip(ftype)
19753 
      iprot.readFieldEnd()
19754 
    iprot.readStructEnd()
19755 
 
19756 
  def write(self, oprot):
19757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19759 
      return
19760 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19761 
    if self.vendorId is not None:
19762 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19763 
      oprot.writeI64(self.vendorId)
19764 
      oprot.writeFieldEnd()
19765 
    if self.itemId is not None:
19766 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19767 
      oprot.writeI64(self.itemId)
19768 
      oprot.writeFieldEnd()
19769 
    if self.quantity is not None:
19770 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19771 
      oprot.writeI64(self.quantity)
19772 
      oprot.writeFieldEnd()
19773 
    if self.estimate is not None:
19774 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19775 
      oprot.writeI64(self.estimate)
19776 
      oprot.writeFieldEnd()
4369 rajveer 19777 
    if self.isReminder is not None:
19778 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19779 
      oprot.writeBool(self.isReminder)
19780 
      oprot.writeFieldEnd()
4303 rajveer 19781 
    oprot.writeFieldStop()
19782 
    oprot.writeStructEnd()
19783 
 
19784 
  def validate(self):
19785 
    return
19786 
 
19787 
 
19788 
  def __repr__(self):
19789 
    L = ['%s=%r' % (key, value)
19790 
      for key, value in self.__dict__.iteritems()]
19791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19792 
 
19793 
  def __eq__(self, other):
19794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19795 
 
19796 
  def __ne__(self, other):
19797 
    return not (self == other)
19798 
 
19799 
class markOrdersAsPORaised_result:
19800 
  """
19801 
  Attributes:
19802 
   - ex
19803 
  """
19804 
 
19805 
  thrift_spec = (
19806 
    None, # 0
19807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19808 
  )
19809 
 
19810 
  def __init__(self, ex=None,):
19811 
    self.ex = ex
19812 
 
19813 
  def read(self, iprot):
19814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19816 
      return
19817 
    iprot.readStructBegin()
19818 
    while True:
19819 
      (fname, ftype, fid) = iprot.readFieldBegin()
19820 
      if ftype == TType.STOP:
19821 
        break
19822 
      if fid == 1:
19823 
        if ftype == TType.STRUCT:
19824 
          self.ex = TransactionServiceException()
19825 
          self.ex.read(iprot)
19826 
        else:
19827 
          iprot.skip(ftype)
19828 
      else:
19829 
        iprot.skip(ftype)
19830 
      iprot.readFieldEnd()
19831 
    iprot.readStructEnd()
19832 
 
19833 
  def write(self, oprot):
19834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19836 
      return
19837 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19838 
    if self.ex is not None:
19839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19840 
      self.ex.write(oprot)
19841 
      oprot.writeFieldEnd()
19842 
    oprot.writeFieldStop()
19843 
    oprot.writeStructEnd()
19844 
 
19845 
  def validate(self):
19846 
    return
19847 
 
19848 
 
19849 
  def __repr__(self):
19850 
    L = ['%s=%r' % (key, value)
19851 
      for key, value in self.__dict__.iteritems()]
19852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19853 
 
19854 
  def __eq__(self, other):
19855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19856 
 
19857 
  def __ne__(self, other):
19858 
    return not (self == other)
19859 
 
19860 
class markOrdersAsReversalInitiated_args:
19861 
  """
19862 
  Attributes:
19863 
   - vendorId
19864 
   - itemId
19865 
   - quantity
19866 
   - estimate
4369 rajveer 19867 
   - isReminder
4303 rajveer 19868 
  """
19869 
 
19870 
  thrift_spec = (
19871 
    None, # 0
19872 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19873 
    (2, TType.I64, 'itemId', None, None, ), # 2
19874 
    (3, TType.I64, 'quantity', None, None, ), # 3
19875 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19876 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19877 
  )
19878 
 
4369 rajveer 19879 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19880 
    self.vendorId = vendorId
19881 
    self.itemId = itemId
19882 
    self.quantity = quantity
19883 
    self.estimate = estimate
4369 rajveer 19884 
    self.isReminder = isReminder
4303 rajveer 19885 
 
19886 
  def read(self, iprot):
19887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19889 
      return
19890 
    iprot.readStructBegin()
19891 
    while True:
19892 
      (fname, ftype, fid) = iprot.readFieldBegin()
19893 
      if ftype == TType.STOP:
19894 
        break
19895 
      if fid == 1:
19896 
        if ftype == TType.I64:
19897 
          self.vendorId = iprot.readI64();
19898 
        else:
19899 
          iprot.skip(ftype)
19900 
      elif fid == 2:
19901 
        if ftype == TType.I64:
19902 
          self.itemId = iprot.readI64();
19903 
        else:
19904 
          iprot.skip(ftype)
19905 
      elif fid == 3:
19906 
        if ftype == TType.I64:
19907 
          self.quantity = iprot.readI64();
19908 
        else:
19909 
          iprot.skip(ftype)
19910 
      elif fid == 4:
19911 
        if ftype == TType.I64:
19912 
          self.estimate = iprot.readI64();
19913 
        else:
19914 
          iprot.skip(ftype)
4369 rajveer 19915 
      elif fid == 5:
19916 
        if ftype == TType.BOOL:
19917 
          self.isReminder = iprot.readBool();
19918 
        else:
19919 
          iprot.skip(ftype)
4303 rajveer 19920 
      else:
19921 
        iprot.skip(ftype)
19922 
      iprot.readFieldEnd()
19923 
    iprot.readStructEnd()
19924 
 
19925 
  def write(self, oprot):
19926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19928 
      return
19929 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19930 
    if self.vendorId is not None:
19931 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19932 
      oprot.writeI64(self.vendorId)
19933 
      oprot.writeFieldEnd()
19934 
    if self.itemId is not None:
19935 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19936 
      oprot.writeI64(self.itemId)
19937 
      oprot.writeFieldEnd()
19938 
    if self.quantity is not None:
19939 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19940 
      oprot.writeI64(self.quantity)
19941 
      oprot.writeFieldEnd()
19942 
    if self.estimate is not None:
19943 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19944 
      oprot.writeI64(self.estimate)
19945 
      oprot.writeFieldEnd()
4369 rajveer 19946 
    if self.isReminder is not None:
19947 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19948 
      oprot.writeBool(self.isReminder)
19949 
      oprot.writeFieldEnd()
4303 rajveer 19950 
    oprot.writeFieldStop()
19951 
    oprot.writeStructEnd()
19952 
 
19953 
  def validate(self):
19954 
    return
19955 
 
19956 
 
19957 
  def __repr__(self):
19958 
    L = ['%s=%r' % (key, value)
19959 
      for key, value in self.__dict__.iteritems()]
19960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19961 
 
19962 
  def __eq__(self, other):
19963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19964 
 
19965 
  def __ne__(self, other):
19966 
    return not (self == other)
19967 
 
19968 
class markOrdersAsReversalInitiated_result:
19969 
  """
19970 
  Attributes:
19971 
   - ex
19972 
  """
19973 
 
19974 
  thrift_spec = (
19975 
    None, # 0
19976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19977 
  )
19978 
 
19979 
  def __init__(self, ex=None,):
19980 
    self.ex = ex
19981 
 
19982 
  def read(self, iprot):
19983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19985 
      return
19986 
    iprot.readStructBegin()
19987 
    while True:
19988 
      (fname, ftype, fid) = iprot.readFieldBegin()
19989 
      if ftype == TType.STOP:
19990 
        break
19991 
      if fid == 1:
19992 
        if ftype == TType.STRUCT:
19993 
          self.ex = TransactionServiceException()
19994 
          self.ex.read(iprot)
19995 
        else:
19996 
          iprot.skip(ftype)
19997 
      else:
19998 
        iprot.skip(ftype)
19999 
      iprot.readFieldEnd()
20000 
    iprot.readStructEnd()
20001 
 
20002 
  def write(self, oprot):
20003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20005 
      return
20006 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20007 
    if self.ex is not None:
20008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20009 
      self.ex.write(oprot)
20010 
      oprot.writeFieldEnd()
20011 
    oprot.writeFieldStop()
20012 
    oprot.writeStructEnd()
20013 
 
20014 
  def validate(self):
20015 
    return
20016 
 
20017 
 
20018 
  def __repr__(self):
20019 
    L = ['%s=%r' % (key, value)
20020 
      for key, value in self.__dict__.iteritems()]
20021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20022 
 
20023 
  def __eq__(self, other):
20024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20025 
 
20026 
  def __ne__(self, other):
20027 
    return not (self == other)
20028 
 
20029 
class markOrdersAsNotAvailabke_args:
20030 
  """
20031 
  Attributes:
20032 
   - vendorId
20033 
   - itemId
20034 
   - quantity
20035 
   - estimate
4369 rajveer 20036 
   - isReminder
4303 rajveer 20037 
  """
20038 
 
20039 
  thrift_spec = (
20040 
    None, # 0
20041 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20042 
    (2, TType.I64, 'itemId', None, None, ), # 2
20043 
    (3, TType.I64, 'quantity', None, None, ), # 3
20044 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20045 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20046 
  )
20047 
 
4369 rajveer 20048 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20049 
    self.vendorId = vendorId
20050 
    self.itemId = itemId
20051 
    self.quantity = quantity
20052 
    self.estimate = estimate
4369 rajveer 20053 
    self.isReminder = isReminder
4303 rajveer 20054 
 
20055 
  def read(self, iprot):
20056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20058 
      return
20059 
    iprot.readStructBegin()
20060 
    while True:
20061 
      (fname, ftype, fid) = iprot.readFieldBegin()
20062 
      if ftype == TType.STOP:
20063 
        break
20064 
      if fid == 1:
20065 
        if ftype == TType.I64:
20066 
          self.vendorId = iprot.readI64();
20067 
        else:
20068 
          iprot.skip(ftype)
20069 
      elif fid == 2:
20070 
        if ftype == TType.I64:
20071 
          self.itemId = iprot.readI64();
20072 
        else:
20073 
          iprot.skip(ftype)
20074 
      elif fid == 3:
20075 
        if ftype == TType.I64:
20076 
          self.quantity = iprot.readI64();
20077 
        else:
20078 
          iprot.skip(ftype)
20079 
      elif fid == 4:
20080 
        if ftype == TType.I64:
20081 
          self.estimate = iprot.readI64();
20082 
        else:
20083 
          iprot.skip(ftype)
4369 rajveer 20084 
      elif fid == 5:
20085 
        if ftype == TType.BOOL:
20086 
          self.isReminder = iprot.readBool();
20087 
        else:
20088 
          iprot.skip(ftype)
4303 rajveer 20089 
      else:
20090 
        iprot.skip(ftype)
20091 
      iprot.readFieldEnd()
20092 
    iprot.readStructEnd()
20093 
 
20094 
  def write(self, oprot):
20095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20097 
      return
20098 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20099 
    if self.vendorId is not None:
20100 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20101 
      oprot.writeI64(self.vendorId)
20102 
      oprot.writeFieldEnd()
20103 
    if self.itemId is not None:
20104 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20105 
      oprot.writeI64(self.itemId)
20106 
      oprot.writeFieldEnd()
20107 
    if self.quantity is not None:
20108 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20109 
      oprot.writeI64(self.quantity)
20110 
      oprot.writeFieldEnd()
20111 
    if self.estimate is not None:
20112 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20113 
      oprot.writeI64(self.estimate)
20114 
      oprot.writeFieldEnd()
4369 rajveer 20115 
    if self.isReminder is not None:
20116 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20117 
      oprot.writeBool(self.isReminder)
20118 
      oprot.writeFieldEnd()
4303 rajveer 20119 
    oprot.writeFieldStop()
20120 
    oprot.writeStructEnd()
20121 
 
20122 
  def validate(self):
20123 
    return
20124 
 
20125 
 
20126 
  def __repr__(self):
20127 
    L = ['%s=%r' % (key, value)
20128 
      for key, value in self.__dict__.iteritems()]
20129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20130 
 
20131 
  def __eq__(self, other):
20132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20133 
 
20134 
  def __ne__(self, other):
20135 
    return not (self == other)
20136 
 
20137 
class markOrdersAsNotAvailabke_result:
20138 
  """
20139 
  Attributes:
20140 
   - ex
20141 
  """
20142 
 
20143 
  thrift_spec = (
20144 
    None, # 0
20145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20146 
  )
20147 
 
20148 
  def __init__(self, ex=None,):
20149 
    self.ex = ex
20150 
 
20151 
  def read(self, iprot):
20152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20154 
      return
20155 
    iprot.readStructBegin()
20156 
    while True:
20157 
      (fname, ftype, fid) = iprot.readFieldBegin()
20158 
      if ftype == TType.STOP:
20159 
        break
20160 
      if fid == 1:
20161 
        if ftype == TType.STRUCT:
20162 
          self.ex = TransactionServiceException()
20163 
          self.ex.read(iprot)
20164 
        else:
20165 
          iprot.skip(ftype)
20166 
      else:
20167 
        iprot.skip(ftype)
20168 
      iprot.readFieldEnd()
20169 
    iprot.readStructEnd()
20170 
 
20171 
  def write(self, oprot):
20172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20174 
      return
20175 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20176 
    if self.ex is not None:
20177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20178 
      self.ex.write(oprot)
20179 
      oprot.writeFieldEnd()
20180 
    oprot.writeFieldStop()
20181 
    oprot.writeStructEnd()
20182 
 
20183 
  def validate(self):
20184 
    return
20185 
 
20186 
 
20187 
  def __repr__(self):
20188 
    L = ['%s=%r' % (key, value)
20189 
      for key, value in self.__dict__.iteritems()]
20190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20191 
 
20192 
  def __eq__(self, other):
20193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20194 
 
20195 
  def __ne__(self, other):
20196 
    return not (self == other)
4369 rajveer 20197 
 
20198 
class markOrdersAsTimeout_args:
20199 
  """
20200 
  Attributes:
20201 
   - vendorId
20202 
  """
20203 
 
20204 
  thrift_spec = (
20205 
    None, # 0
20206 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20207 
  )
20208 
 
20209 
  def __init__(self, vendorId=None,):
20210 
    self.vendorId = vendorId
20211 
 
20212 
  def read(self, iprot):
20213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20215 
      return
20216 
    iprot.readStructBegin()
20217 
    while True:
20218 
      (fname, ftype, fid) = iprot.readFieldBegin()
20219 
      if ftype == TType.STOP:
20220 
        break
20221 
      if fid == 1:
20222 
        if ftype == TType.I64:
20223 
          self.vendorId = iprot.readI64();
20224 
        else:
20225 
          iprot.skip(ftype)
20226 
      else:
20227 
        iprot.skip(ftype)
20228 
      iprot.readFieldEnd()
20229 
    iprot.readStructEnd()
20230 
 
20231 
  def write(self, oprot):
20232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20234 
      return
20235 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20236 
    if self.vendorId is not None:
20237 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20238 
      oprot.writeI64(self.vendorId)
20239 
      oprot.writeFieldEnd()
20240 
    oprot.writeFieldStop()
20241 
    oprot.writeStructEnd()
20242 
 
20243 
  def validate(self):
20244 
    return
20245 
 
20246 
 
20247 
  def __repr__(self):
20248 
    L = ['%s=%r' % (key, value)
20249 
      for key, value in self.__dict__.iteritems()]
20250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20251 
 
20252 
  def __eq__(self, other):
20253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20254 
 
20255 
  def __ne__(self, other):
20256 
    return not (self == other)
20257 
 
20258 
class markOrdersAsTimeout_result:
20259 
  """
20260 
  Attributes:
20261 
   - success
20262 
   - ex
20263 
  """
20264 
 
20265 
  thrift_spec = (
20266 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20268 
  )
20269 
 
20270 
  def __init__(self, success=None, ex=None,):
20271 
    self.success = success
20272 
    self.ex = ex
20273 
 
20274 
  def read(self, iprot):
20275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20277 
      return
20278 
    iprot.readStructBegin()
20279 
    while True:
20280 
      (fname, ftype, fid) = iprot.readFieldBegin()
20281 
      if ftype == TType.STOP:
20282 
        break
20283 
      if fid == 0:
20284 
        if ftype == TType.MAP:
20285 
          self.success = {}
5481 phani.kuma 20286 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
20287 
          for _i448 in xrange(_size444):
20288 
            _key449 = iprot.readI32();
20289 
            _val450 = TimeoutSummary()
20290 
            _val450.read(iprot)
20291 
            self.success[_key449] = _val450
4369 rajveer 20292 
          iprot.readMapEnd()
20293 
        else:
20294 
          iprot.skip(ftype)
20295 
      elif fid == 1:
20296 
        if ftype == TType.STRUCT:
20297 
          self.ex = TransactionServiceException()
20298 
          self.ex.read(iprot)
20299 
        else:
20300 
          iprot.skip(ftype)
20301 
      else:
20302 
        iprot.skip(ftype)
20303 
      iprot.readFieldEnd()
20304 
    iprot.readStructEnd()
20305 
 
20306 
  def write(self, oprot):
20307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20309 
      return
20310 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20311 
    if self.success is not None:
20312 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20313 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5481 phani.kuma 20314 
      for kiter451,viter452 in self.success.items():
20315 
        oprot.writeI32(kiter451)
20316 
        viter452.write(oprot)
4369 rajveer 20317 
      oprot.writeMapEnd()
20318 
      oprot.writeFieldEnd()
20319 
    if self.ex is not None:
20320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20321 
      self.ex.write(oprot)
20322 
      oprot.writeFieldEnd()
20323 
    oprot.writeFieldStop()
20324 
    oprot.writeStructEnd()
20325 
 
20326 
  def validate(self):
20327 
    return
20328 
 
20329 
 
20330 
  def __repr__(self):
20331 
    L = ['%s=%r' % (key, value)
20332 
      for key, value in self.__dict__.iteritems()]
20333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20334 
 
20335 
  def __eq__(self, other):
20336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20337 
 
20338 
  def __ne__(self, other):
20339 
    return not (self == other)
4386 anupam.sin 20340 
 
4662 rajveer 20341 
class markOrderAsLostInTransit_args:
20342 
  """
20343 
  Attributes:
20344 
   - orderId
20345 
  """
20346 
 
20347 
  thrift_spec = (
20348 
    None, # 0
20349 
    (1, TType.I64, 'orderId', None, None, ), # 1
20350 
  )
20351 
 
20352 
  def __init__(self, orderId=None,):
20353 
    self.orderId = orderId
20354 
 
20355 
  def read(self, iprot):
20356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20358 
      return
20359 
    iprot.readStructBegin()
20360 
    while True:
20361 
      (fname, ftype, fid) = iprot.readFieldBegin()
20362 
      if ftype == TType.STOP:
20363 
        break
20364 
      if fid == 1:
20365 
        if ftype == TType.I64:
20366 
          self.orderId = iprot.readI64();
20367 
        else:
20368 
          iprot.skip(ftype)
20369 
      else:
20370 
        iprot.skip(ftype)
20371 
      iprot.readFieldEnd()
20372 
    iprot.readStructEnd()
20373 
 
20374 
  def write(self, oprot):
20375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20377 
      return
20378 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20379 
    if self.orderId is not None:
20380 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20381 
      oprot.writeI64(self.orderId)
20382 
      oprot.writeFieldEnd()
20383 
    oprot.writeFieldStop()
20384 
    oprot.writeStructEnd()
20385 
 
20386 
  def validate(self):
20387 
    return
20388 
 
20389 
 
20390 
  def __repr__(self):
20391 
    L = ['%s=%r' % (key, value)
20392 
      for key, value in self.__dict__.iteritems()]
20393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20394 
 
20395 
  def __eq__(self, other):
20396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20397 
 
20398 
  def __ne__(self, other):
20399 
    return not (self == other)
20400 
 
20401 
class markOrderAsLostInTransit_result:
20402 
  """
20403 
  Attributes:
20404 
   - success
20405 
   - ex
20406 
  """
20407 
 
20408 
  thrift_spec = (
20409 
    (0, TType.BOOL, 'success', None, None, ), # 0
20410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20411 
  )
20412 
 
20413 
  def __init__(self, success=None, ex=None,):
20414 
    self.success = success
20415 
    self.ex = ex
20416 
 
20417 
  def read(self, iprot):
20418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20420 
      return
20421 
    iprot.readStructBegin()
20422 
    while True:
20423 
      (fname, ftype, fid) = iprot.readFieldBegin()
20424 
      if ftype == TType.STOP:
20425 
        break
20426 
      if fid == 0:
20427 
        if ftype == TType.BOOL:
20428 
          self.success = iprot.readBool();
20429 
        else:
20430 
          iprot.skip(ftype)
20431 
      elif fid == 1:
20432 
        if ftype == TType.STRUCT:
20433 
          self.ex = TransactionServiceException()
20434 
          self.ex.read(iprot)
20435 
        else:
20436 
          iprot.skip(ftype)
20437 
      else:
20438 
        iprot.skip(ftype)
20439 
      iprot.readFieldEnd()
20440 
    iprot.readStructEnd()
20441 
 
20442 
  def write(self, oprot):
20443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20445 
      return
20446 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20447 
    if self.success is not None:
20448 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20449 
      oprot.writeBool(self.success)
20450 
      oprot.writeFieldEnd()
20451 
    if self.ex is not None:
20452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20453 
      self.ex.write(oprot)
20454 
      oprot.writeFieldEnd()
20455 
    oprot.writeFieldStop()
20456 
    oprot.writeStructEnd()
20457 
 
20458 
  def validate(self):
20459 
    return
20460 
 
20461 
 
20462 
  def __repr__(self):
20463 
    L = ['%s=%r' % (key, value)
20464 
      for key, value in self.__dict__.iteritems()]
20465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20466 
 
20467 
  def __eq__(self, other):
20468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20469 
 
20470 
  def __ne__(self, other):
20471 
    return not (self == other)
20472 
 
4386 anupam.sin 20473 
class getOrderForAwb_args:
20474 
  """
20475 
  Attributes:
20476 
   - awb
20477 
  """
20478 
 
20479 
  thrift_spec = (
20480 
    None, # 0
20481 
    (1, TType.STRING, 'awb', None, None, ), # 1
20482 
  )
20483 
 
20484 
  def __init__(self, awb=None,):
20485 
    self.awb = awb
20486 
 
20487 
  def read(self, iprot):
20488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20490 
      return
20491 
    iprot.readStructBegin()
20492 
    while True:
20493 
      (fname, ftype, fid) = iprot.readFieldBegin()
20494 
      if ftype == TType.STOP:
20495 
        break
20496 
      if fid == 1:
20497 
        if ftype == TType.STRING:
20498 
          self.awb = iprot.readString();
20499 
        else:
20500 
          iprot.skip(ftype)
20501 
      else:
20502 
        iprot.skip(ftype)
20503 
      iprot.readFieldEnd()
20504 
    iprot.readStructEnd()
20505 
 
20506 
  def write(self, oprot):
20507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20509 
      return
20510 
    oprot.writeStructBegin('getOrderForAwb_args')
20511 
    if self.awb is not None:
20512 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20513 
      oprot.writeString(self.awb)
20514 
      oprot.writeFieldEnd()
20515 
    oprot.writeFieldStop()
20516 
    oprot.writeStructEnd()
20517 
 
20518 
  def validate(self):
20519 
    return
20520 
 
20521 
 
20522 
  def __repr__(self):
20523 
    L = ['%s=%r' % (key, value)
20524 
      for key, value in self.__dict__.iteritems()]
20525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20526 
 
20527 
  def __eq__(self, other):
20528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20529 
 
20530 
  def __ne__(self, other):
20531 
    return not (self == other)
20532 
 
20533 
class getOrderForAwb_result:
20534 
  """
20535 
  Attributes:
20536 
   - success
20537 
   - ex
20538 
  """
20539 
 
20540 
  thrift_spec = (
20541 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20543 
  )
20544 
 
20545 
  def __init__(self, success=None, ex=None,):
20546 
    self.success = success
20547 
    self.ex = ex
20548 
 
20549 
  def read(self, iprot):
20550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20552 
      return
20553 
    iprot.readStructBegin()
20554 
    while True:
20555 
      (fname, ftype, fid) = iprot.readFieldBegin()
20556 
      if ftype == TType.STOP:
20557 
        break
20558 
      if fid == 0:
20559 
        if ftype == TType.STRUCT:
20560 
          self.success = Order()
20561 
          self.success.read(iprot)
20562 
        else:
20563 
          iprot.skip(ftype)
20564 
      elif fid == 1:
20565 
        if ftype == TType.STRUCT:
20566 
          self.ex = TransactionServiceException()
20567 
          self.ex.read(iprot)
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      else:
20571 
        iprot.skip(ftype)
20572 
      iprot.readFieldEnd()
20573 
    iprot.readStructEnd()
20574 
 
20575 
  def write(self, oprot):
20576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20578 
      return
20579 
    oprot.writeStructBegin('getOrderForAwb_result')
20580 
    if self.success is not None:
20581 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20582 
      self.success.write(oprot)
20583 
      oprot.writeFieldEnd()
20584 
    if self.ex is not None:
20585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20586 
      self.ex.write(oprot)
20587 
      oprot.writeFieldEnd()
20588 
    oprot.writeFieldStop()
20589 
    oprot.writeStructEnd()
20590 
 
20591 
  def validate(self):
20592 
    return
20593 
 
20594 
 
20595 
  def __repr__(self):
20596 
    L = ['%s=%r' % (key, value)
20597 
      for key, value in self.__dict__.iteritems()]
20598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20599 
 
20600 
  def __eq__(self, other):
20601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20602 
 
20603 
  def __ne__(self, other):
20604 
    return not (self == other)
4506 phani.kuma 20605 
 
20606 
class getOrdersForProviderForStatus_args:
20607 
  """
20608 
  Attributes:
20609 
   - logistics_provider_id
4910 phani.kuma 20610 
   - order_status_list
4506 phani.kuma 20611 
  """
20612 
 
20613 
  thrift_spec = (
20614 
    None, # 0
20615 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20616 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20617 
  )
20618 
 
4910 phani.kuma 20619 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20620 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20621 
    self.order_status_list = order_status_list
4506 phani.kuma 20622 
 
20623 
  def read(self, iprot):
20624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20626 
      return
20627 
    iprot.readStructBegin()
20628 
    while True:
20629 
      (fname, ftype, fid) = iprot.readFieldBegin()
20630 
      if ftype == TType.STOP:
20631 
        break
20632 
      if fid == 1:
20633 
        if ftype == TType.I64:
20634 
          self.logistics_provider_id = iprot.readI64();
20635 
        else:
20636 
          iprot.skip(ftype)
20637 
      elif fid == 2:
4910 phani.kuma 20638 
        if ftype == TType.LIST:
20639 
          self.order_status_list = []
5481 phani.kuma 20640 
          (_etype456, _size453) = iprot.readListBegin()
20641 
          for _i457 in xrange(_size453):
20642 
            _elem458 = iprot.readI32();
20643 
            self.order_status_list.append(_elem458)
4910 phani.kuma 20644 
          iprot.readListEnd()
4506 phani.kuma 20645 
        else:
20646 
          iprot.skip(ftype)
20647 
      else:
20648 
        iprot.skip(ftype)
20649 
      iprot.readFieldEnd()
20650 
    iprot.readStructEnd()
20651 
 
20652 
  def write(self, oprot):
20653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20655 
      return
20656 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
20657 
    if self.logistics_provider_id is not None:
20658 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
20659 
      oprot.writeI64(self.logistics_provider_id)
20660 
      oprot.writeFieldEnd()
4910 phani.kuma 20661 
    if self.order_status_list is not None:
20662 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
20663 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5481 phani.kuma 20664 
      for iter459 in self.order_status_list:
20665 
        oprot.writeI32(iter459)
4910 phani.kuma 20666 
      oprot.writeListEnd()
4506 phani.kuma 20667 
      oprot.writeFieldEnd()
20668 
    oprot.writeFieldStop()
20669 
    oprot.writeStructEnd()
20670 
 
20671 
  def validate(self):
20672 
    return
20673 
 
20674 
 
20675 
  def __repr__(self):
20676 
    L = ['%s=%r' % (key, value)
20677 
      for key, value in self.__dict__.iteritems()]
20678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20679 
 
20680 
  def __eq__(self, other):
20681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20682 
 
20683 
  def __ne__(self, other):
20684 
    return not (self == other)
20685 
 
20686 
class getOrdersForProviderForStatus_result:
20687 
  """
20688 
  Attributes:
20689 
   - success
20690 
   - ex
20691 
  """
20692 
 
20693 
  thrift_spec = (
20694 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20696 
  )
20697 
 
20698 
  def __init__(self, success=None, ex=None,):
20699 
    self.success = success
20700 
    self.ex = ex
20701 
 
20702 
  def read(self, iprot):
20703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20705 
      return
20706 
    iprot.readStructBegin()
20707 
    while True:
20708 
      (fname, ftype, fid) = iprot.readFieldBegin()
20709 
      if ftype == TType.STOP:
20710 
        break
20711 
      if fid == 0:
20712 
        if ftype == TType.LIST:
20713 
          self.success = []
5481 phani.kuma 20714 
          (_etype463, _size460) = iprot.readListBegin()
20715 
          for _i464 in xrange(_size460):
20716 
            _elem465 = Order()
20717 
            _elem465.read(iprot)
20718 
            self.success.append(_elem465)
4506 phani.kuma 20719 
          iprot.readListEnd()
20720 
        else:
20721 
          iprot.skip(ftype)
20722 
      elif fid == 1:
20723 
        if ftype == TType.STRUCT:
20724 
          self.ex = TransactionServiceException()
20725 
          self.ex.read(iprot)
20726 
        else:
20727 
          iprot.skip(ftype)
20728 
      else:
20729 
        iprot.skip(ftype)
20730 
      iprot.readFieldEnd()
20731 
    iprot.readStructEnd()
20732 
 
20733 
  def write(self, oprot):
20734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20736 
      return
20737 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
20738 
    if self.success is not None:
20739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20741 
      for iter466 in self.success:
20742 
        iter466.write(oprot)
4506 phani.kuma 20743 
      oprot.writeListEnd()
20744 
      oprot.writeFieldEnd()
20745 
    if self.ex is not None:
20746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20747 
      self.ex.write(oprot)
20748 
      oprot.writeFieldEnd()
20749 
    oprot.writeFieldStop()
20750 
    oprot.writeStructEnd()
20751 
 
20752 
  def validate(self):
20753 
    return
20754 
 
20755 
 
20756 
  def __repr__(self):
20757 
    L = ['%s=%r' % (key, value)
20758 
      for key, value in self.__dict__.iteritems()]
20759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20760 
 
20761 
  def __eq__(self, other):
20762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20763 
 
20764 
  def __ne__(self, other):
20765 
    return not (self == other)
4600 varun.gupt 20766 
 
20767 
class getBilledOrdersForVendor_args:
20768 
  """
20769 
  Attributes:
20770 
   - vendorId
20771 
   - billingDateFrom
20772 
   - billingDateTo
20773 
  """
20774 
 
20775 
  thrift_spec = (
20776 
    None, # 0
20777 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20778 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20779 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20780 
  )
20781 
 
20782 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20783 
    self.vendorId = vendorId
20784 
    self.billingDateFrom = billingDateFrom
20785 
    self.billingDateTo = billingDateTo
20786 
 
20787 
  def read(self, iprot):
20788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20790 
      return
20791 
    iprot.readStructBegin()
20792 
    while True:
20793 
      (fname, ftype, fid) = iprot.readFieldBegin()
20794 
      if ftype == TType.STOP:
20795 
        break
20796 
      if fid == 1:
20797 
        if ftype == TType.I64:
20798 
          self.vendorId = iprot.readI64();
20799 
        else:
20800 
          iprot.skip(ftype)
20801 
      elif fid == 2:
20802 
        if ftype == TType.I64:
20803 
          self.billingDateFrom = iprot.readI64();
20804 
        else:
20805 
          iprot.skip(ftype)
20806 
      elif fid == 3:
20807 
        if ftype == TType.I64:
20808 
          self.billingDateTo = iprot.readI64();
20809 
        else:
20810 
          iprot.skip(ftype)
20811 
      else:
20812 
        iprot.skip(ftype)
20813 
      iprot.readFieldEnd()
20814 
    iprot.readStructEnd()
20815 
 
20816 
  def write(self, oprot):
20817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20819 
      return
20820 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20821 
    if self.vendorId is not None:
20822 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20823 
      oprot.writeI64(self.vendorId)
20824 
      oprot.writeFieldEnd()
20825 
    if self.billingDateFrom is not None:
20826 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20827 
      oprot.writeI64(self.billingDateFrom)
20828 
      oprot.writeFieldEnd()
20829 
    if self.billingDateTo is not None:
20830 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20831 
      oprot.writeI64(self.billingDateTo)
20832 
      oprot.writeFieldEnd()
20833 
    oprot.writeFieldStop()
20834 
    oprot.writeStructEnd()
20835 
 
20836 
  def validate(self):
20837 
    return
20838 
 
20839 
 
20840 
  def __repr__(self):
20841 
    L = ['%s=%r' % (key, value)
20842 
      for key, value in self.__dict__.iteritems()]
20843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20844 
 
20845 
  def __eq__(self, other):
20846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20847 
 
20848 
  def __ne__(self, other):
20849 
    return not (self == other)
20850 
 
20851 
class getBilledOrdersForVendor_result:
20852 
  """
20853 
  Attributes:
20854 
   - success
20855 
   - ex
20856 
  """
20857 
 
20858 
  thrift_spec = (
20859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20861 
  )
20862 
 
20863 
  def __init__(self, success=None, ex=None,):
20864 
    self.success = success
20865 
    self.ex = ex
20866 
 
20867 
  def read(self, iprot):
20868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20870 
      return
20871 
    iprot.readStructBegin()
20872 
    while True:
20873 
      (fname, ftype, fid) = iprot.readFieldBegin()
20874 
      if ftype == TType.STOP:
20875 
        break
20876 
      if fid == 0:
20877 
        if ftype == TType.LIST:
20878 
          self.success = []
5481 phani.kuma 20879 
          (_etype470, _size467) = iprot.readListBegin()
20880 
          for _i471 in xrange(_size467):
20881 
            _elem472 = Order()
20882 
            _elem472.read(iprot)
20883 
            self.success.append(_elem472)
4600 varun.gupt 20884 
          iprot.readListEnd()
20885 
        else:
20886 
          iprot.skip(ftype)
20887 
      elif fid == 1:
20888 
        if ftype == TType.STRUCT:
20889 
          self.ex = TransactionServiceException()
20890 
          self.ex.read(iprot)
20891 
        else:
20892 
          iprot.skip(ftype)
20893 
      else:
20894 
        iprot.skip(ftype)
20895 
      iprot.readFieldEnd()
20896 
    iprot.readStructEnd()
20897 
 
20898 
  def write(self, oprot):
20899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20901 
      return
20902 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20903 
    if self.success is not None:
20904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20906 
      for iter473 in self.success:
20907 
        iter473.write(oprot)
4600 varun.gupt 20908 
      oprot.writeListEnd()
20909 
      oprot.writeFieldEnd()
20910 
    if self.ex is not None:
20911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20912 
      self.ex.write(oprot)
20913 
      oprot.writeFieldEnd()
20914 
    oprot.writeFieldStop()
20915 
    oprot.writeStructEnd()
20916 
 
20917 
  def validate(self):
20918 
    return
20919 
 
20920 
 
20921 
  def __repr__(self):
20922 
    L = ['%s=%r' % (key, value)
20923 
      for key, value in self.__dict__.iteritems()]
20924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20925 
 
20926 
  def __eq__(self, other):
20927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20928 
 
20929 
  def __ne__(self, other):
20930 
    return not (self == other)
20931 
 
4607 rajveer 20932 
class getSlippedSippingDateOrders_args:
20933 
 
20934 
  thrift_spec = (
20935 
  )
20936 
 
20937 
  def read(self, iprot):
20938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20940 
      return
20941 
    iprot.readStructBegin()
20942 
    while True:
20943 
      (fname, ftype, fid) = iprot.readFieldBegin()
20944 
      if ftype == TType.STOP:
20945 
        break
20946 
      else:
20947 
        iprot.skip(ftype)
20948 
      iprot.readFieldEnd()
20949 
    iprot.readStructEnd()
20950 
 
20951 
  def write(self, oprot):
20952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20954 
      return
20955 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20956 
    oprot.writeFieldStop()
20957 
    oprot.writeStructEnd()
20958 
 
20959 
  def validate(self):
20960 
    return
20961 
 
20962 
 
20963 
  def __repr__(self):
20964 
    L = ['%s=%r' % (key, value)
20965 
      for key, value in self.__dict__.iteritems()]
20966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20967 
 
20968 
  def __eq__(self, other):
20969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20970 
 
20971 
  def __ne__(self, other):
20972 
    return not (self == other)
20973 
 
20974 
class getSlippedSippingDateOrders_result:
20975 
  """
20976 
  Attributes:
20977 
   - success
20978 
   - ex
20979 
  """
20980 
 
20981 
  thrift_spec = (
20982 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20984 
  )
20985 
 
20986 
  def __init__(self, success=None, ex=None,):
20987 
    self.success = success
20988 
    self.ex = ex
20989 
 
20990 
  def read(self, iprot):
20991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20993 
      return
20994 
    iprot.readStructBegin()
20995 
    while True:
20996 
      (fname, ftype, fid) = iprot.readFieldBegin()
20997 
      if ftype == TType.STOP:
20998 
        break
20999 
      if fid == 0:
21000 
        if ftype == TType.LIST:
21001 
          self.success = []
5481 phani.kuma 21002 
          (_etype477, _size474) = iprot.readListBegin()
21003 
          for _i478 in xrange(_size474):
21004 
            _elem479 = Order()
21005 
            _elem479.read(iprot)
21006 
            self.success.append(_elem479)
4607 rajveer 21007 
          iprot.readListEnd()
21008 
        else:
21009 
          iprot.skip(ftype)
21010 
      elif fid == 1:
21011 
        if ftype == TType.STRUCT:
21012 
          self.ex = TransactionServiceException()
21013 
          self.ex.read(iprot)
21014 
        else:
21015 
          iprot.skip(ftype)
21016 
      else:
21017 
        iprot.skip(ftype)
21018 
      iprot.readFieldEnd()
21019 
    iprot.readStructEnd()
21020 
 
21021 
  def write(self, oprot):
21022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21024 
      return
21025 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21026 
    if self.success is not None:
21027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 21029 
      for iter480 in self.success:
21030 
        iter480.write(oprot)
4607 rajveer 21031 
      oprot.writeListEnd()
21032 
      oprot.writeFieldEnd()
21033 
    if self.ex is not None:
21034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21035 
      self.ex.write(oprot)
21036 
      oprot.writeFieldEnd()
21037 
    oprot.writeFieldStop()
21038 
    oprot.writeStructEnd()
21039 
 
21040 
  def validate(self):
21041 
    return
21042 
 
21043 
 
21044 
  def __repr__(self):
21045 
    L = ['%s=%r' % (key, value)
21046 
      for key, value in self.__dict__.iteritems()]
21047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21048 
 
21049 
  def __eq__(self, other):
21050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21051 
 
21052 
  def __ne__(self, other):
21053 
    return not (self == other)
21054 
 
4709 rajveer 21055 
class getCancelledOrders_args:
21056 
  """
21057 
  Attributes:
21058 
   - cancelDateFrom
21059 
   - cancelDateTo
21060 
  """
21061 
 
21062 
  thrift_spec = (
21063 
    None, # 0
21064 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21065 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21066 
  )
21067 
 
21068 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21069 
    self.cancelDateFrom = cancelDateFrom
21070 
    self.cancelDateTo = cancelDateTo
21071 
 
21072 
  def read(self, iprot):
21073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21075 
      return
21076 
    iprot.readStructBegin()
21077 
    while True:
21078 
      (fname, ftype, fid) = iprot.readFieldBegin()
21079 
      if ftype == TType.STOP:
21080 
        break
21081 
      if fid == 1:
21082 
        if ftype == TType.I64:
21083 
          self.cancelDateFrom = iprot.readI64();
21084 
        else:
21085 
          iprot.skip(ftype)
21086 
      elif fid == 2:
21087 
        if ftype == TType.I64:
21088 
          self.cancelDateTo = iprot.readI64();
21089 
        else:
21090 
          iprot.skip(ftype)
21091 
      else:
21092 
        iprot.skip(ftype)
21093 
      iprot.readFieldEnd()
21094 
    iprot.readStructEnd()
21095 
 
21096 
  def write(self, oprot):
21097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21099 
      return
21100 
    oprot.writeStructBegin('getCancelledOrders_args')
21101 
    if self.cancelDateFrom is not None:
21102 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21103 
      oprot.writeI64(self.cancelDateFrom)
21104 
      oprot.writeFieldEnd()
21105 
    if self.cancelDateTo is not None:
21106 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21107 
      oprot.writeI64(self.cancelDateTo)
21108 
      oprot.writeFieldEnd()
21109 
    oprot.writeFieldStop()
21110 
    oprot.writeStructEnd()
21111 
 
21112 
  def validate(self):
21113 
    return
21114 
 
21115 
 
21116 
  def __repr__(self):
21117 
    L = ['%s=%r' % (key, value)
21118 
      for key, value in self.__dict__.iteritems()]
21119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21120 
 
21121 
  def __eq__(self, other):
21122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21123 
 
21124 
  def __ne__(self, other):
21125 
    return not (self == other)
21126 
 
21127 
class getCancelledOrders_result:
21128 
  """
21129 
  Attributes:
21130 
   - success
21131 
   - ex
21132 
  """
21133 
 
21134 
  thrift_spec = (
21135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21137 
  )
21138 
 
21139 
  def __init__(self, success=None, ex=None,):
21140 
    self.success = success
21141 
    self.ex = ex
21142 
 
21143 
  def read(self, iprot):
21144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21146 
      return
21147 
    iprot.readStructBegin()
21148 
    while True:
21149 
      (fname, ftype, fid) = iprot.readFieldBegin()
21150 
      if ftype == TType.STOP:
21151 
        break
21152 
      if fid == 0:
21153 
        if ftype == TType.LIST:
21154 
          self.success = []
5481 phani.kuma 21155 
          (_etype484, _size481) = iprot.readListBegin()
21156 
          for _i485 in xrange(_size481):
21157 
            _elem486 = Order()
21158 
            _elem486.read(iprot)
21159 
            self.success.append(_elem486)
4709 rajveer 21160 
          iprot.readListEnd()
21161 
        else:
21162 
          iprot.skip(ftype)
21163 
      elif fid == 1:
21164 
        if ftype == TType.STRUCT:
21165 
          self.ex = TransactionServiceException()
21166 
          self.ex.read(iprot)
21167 
        else:
21168 
          iprot.skip(ftype)
21169 
      else:
21170 
        iprot.skip(ftype)
21171 
      iprot.readFieldEnd()
21172 
    iprot.readStructEnd()
21173 
 
21174 
  def write(self, oprot):
21175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21177 
      return
21178 
    oprot.writeStructBegin('getCancelledOrders_result')
21179 
    if self.success is not None:
21180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 21182 
      for iter487 in self.success:
21183 
        iter487.write(oprot)
4709 rajveer 21184 
      oprot.writeListEnd()
21185 
      oprot.writeFieldEnd()
21186 
    if self.ex is not None:
21187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21188 
      self.ex.write(oprot)
21189 
      oprot.writeFieldEnd()
21190 
    oprot.writeFieldStop()
21191 
    oprot.writeStructEnd()
21192 
 
21193 
  def validate(self):
21194 
    return
21195 
 
21196 
 
21197 
  def __repr__(self):
21198 
    L = ['%s=%r' % (key, value)
21199 
      for key, value in self.__dict__.iteritems()]
21200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21201 
 
21202 
  def __eq__(self, other):
21203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21204 
 
21205 
  def __ne__(self, other):
21206 
    return not (self == other)
21207 
 
4600 varun.gupt 21208 
class saveBluedartSettlements_args:
21209 
  """
21210 
  Attributes:
21211 
   - mapAWBAndAmount
21212 
  """
21213 
 
21214 
  thrift_spec = (
21215 
    None, # 0
21216 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21217 
  )
21218 
 
21219 
  def __init__(self, mapAWBAndAmount=None,):
21220 
    self.mapAWBAndAmount = mapAWBAndAmount
21221 
 
21222 
  def read(self, iprot):
21223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21225 
      return
21226 
    iprot.readStructBegin()
21227 
    while True:
21228 
      (fname, ftype, fid) = iprot.readFieldBegin()
21229 
      if ftype == TType.STOP:
21230 
        break
21231 
      if fid == 1:
21232 
        if ftype == TType.MAP:
21233 
          self.mapAWBAndAmount = {}
5481 phani.kuma 21234 
          (_ktype489, _vtype490, _size488 ) = iprot.readMapBegin()
21235 
          for _i492 in xrange(_size488):
21236 
            _key493 = iprot.readI64();
21237 
            _val494 = iprot.readDouble();
21238 
            self.mapAWBAndAmount[_key493] = _val494
4600 varun.gupt 21239 
          iprot.readMapEnd()
21240 
        else:
21241 
          iprot.skip(ftype)
21242 
      else:
21243 
        iprot.skip(ftype)
21244 
      iprot.readFieldEnd()
21245 
    iprot.readStructEnd()
21246 
 
21247 
  def write(self, oprot):
21248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21250 
      return
21251 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21252 
    if self.mapAWBAndAmount is not None:
21253 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21254 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5481 phani.kuma 21255 
      for kiter495,viter496 in self.mapAWBAndAmount.items():
21256 
        oprot.writeI64(kiter495)
21257 
        oprot.writeDouble(viter496)
4600 varun.gupt 21258 
      oprot.writeMapEnd()
21259 
      oprot.writeFieldEnd()
21260 
    oprot.writeFieldStop()
21261 
    oprot.writeStructEnd()
21262 
 
21263 
  def validate(self):
21264 
    return
21265 
 
21266 
 
21267 
  def __repr__(self):
21268 
    L = ['%s=%r' % (key, value)
21269 
      for key, value in self.__dict__.iteritems()]
21270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21271 
 
21272 
  def __eq__(self, other):
21273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21274 
 
21275 
  def __ne__(self, other):
21276 
    return not (self == other)
21277 
 
21278 
class saveBluedartSettlements_result:
21279 
  """
21280 
  Attributes:
21281 
   - ex
21282 
  """
21283 
 
21284 
  thrift_spec = (
21285 
    None, # 0
21286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21287 
  )
21288 
 
21289 
  def __init__(self, ex=None,):
21290 
    self.ex = ex
21291 
 
21292 
  def read(self, iprot):
21293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21295 
      return
21296 
    iprot.readStructBegin()
21297 
    while True:
21298 
      (fname, ftype, fid) = iprot.readFieldBegin()
21299 
      if ftype == TType.STOP:
21300 
        break
21301 
      if fid == 1:
21302 
        if ftype == TType.STRUCT:
21303 
          self.ex = TransactionServiceException()
21304 
          self.ex.read(iprot)
21305 
        else:
21306 
          iprot.skip(ftype)
21307 
      else:
21308 
        iprot.skip(ftype)
21309 
      iprot.readFieldEnd()
21310 
    iprot.readStructEnd()
21311 
 
21312 
  def write(self, oprot):
21313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21315 
      return
21316 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21317 
    if self.ex is not None:
21318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21319 
      self.ex.write(oprot)
21320 
      oprot.writeFieldEnd()
21321 
    oprot.writeFieldStop()
21322 
    oprot.writeStructEnd()
21323 
 
21324 
  def validate(self):
21325 
    return
21326 
 
21327 
 
21328 
  def __repr__(self):
21329 
    L = ['%s=%r' % (key, value)
21330 
      for key, value in self.__dict__.iteritems()]
21331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21332 
 
21333 
  def __eq__(self, other):
21334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21335 
 
21336 
  def __ne__(self, other):
21337 
    return not (self == other)
21338 
 
21339 
class savePaymentSettlements_args:
21340 
  """
21341 
  Attributes:
21342 
   - settlementDate
21343 
   - paymentGatewayId
4905 varun.gupt 21344 
   - referenceId
4600 varun.gupt 21345 
   - serviceTax
21346 
   - otherCharges
21347 
   - netCollection
21348 
  """
21349 
 
21350 
  thrift_spec = (
21351 
    None, # 0
21352 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21353 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21354 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21355 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21356 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21357 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21358 
  )
21359 
 
4905 varun.gupt 21360 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21361 
    self.settlementDate = settlementDate
21362 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21363 
    self.referenceId = referenceId
4600 varun.gupt 21364 
    self.serviceTax = serviceTax
21365 
    self.otherCharges = otherCharges
21366 
    self.netCollection = netCollection
21367 
 
21368 
  def read(self, iprot):
21369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21371 
      return
21372 
    iprot.readStructBegin()
21373 
    while True:
21374 
      (fname, ftype, fid) = iprot.readFieldBegin()
21375 
      if ftype == TType.STOP:
21376 
        break
21377 
      if fid == 1:
21378 
        if ftype == TType.I64:
21379 
          self.settlementDate = iprot.readI64();
21380 
        else:
21381 
          iprot.skip(ftype)
21382 
      elif fid == 2:
21383 
        if ftype == TType.I64:
21384 
          self.paymentGatewayId = iprot.readI64();
21385 
        else:
21386 
          iprot.skip(ftype)
21387 
      elif fid == 3:
21388 
        if ftype == TType.I64:
4905 varun.gupt 21389 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21390 
        else:
21391 
          iprot.skip(ftype)
21392 
      elif fid == 4:
21393 
        if ftype == TType.DOUBLE:
21394 
          self.serviceTax = iprot.readDouble();
21395 
        else:
21396 
          iprot.skip(ftype)
21397 
      elif fid == 5:
21398 
        if ftype == TType.DOUBLE:
21399 
          self.otherCharges = iprot.readDouble();
21400 
        else:
21401 
          iprot.skip(ftype)
21402 
      elif fid == 6:
21403 
        if ftype == TType.DOUBLE:
21404 
          self.netCollection = iprot.readDouble();
21405 
        else:
21406 
          iprot.skip(ftype)
21407 
      else:
21408 
        iprot.skip(ftype)
21409 
      iprot.readFieldEnd()
21410 
    iprot.readStructEnd()
21411 
 
21412 
  def write(self, oprot):
21413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21415 
      return
21416 
    oprot.writeStructBegin('savePaymentSettlements_args')
21417 
    if self.settlementDate is not None:
21418 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21419 
      oprot.writeI64(self.settlementDate)
21420 
      oprot.writeFieldEnd()
21421 
    if self.paymentGatewayId is not None:
21422 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21423 
      oprot.writeI64(self.paymentGatewayId)
21424 
      oprot.writeFieldEnd()
4905 varun.gupt 21425 
    if self.referenceId is not None:
21426 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21427 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21428 
      oprot.writeFieldEnd()
21429 
    if self.serviceTax is not None:
21430 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21431 
      oprot.writeDouble(self.serviceTax)
21432 
      oprot.writeFieldEnd()
21433 
    if self.otherCharges is not None:
21434 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21435 
      oprot.writeDouble(self.otherCharges)
21436 
      oprot.writeFieldEnd()
21437 
    if self.netCollection is not None:
21438 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21439 
      oprot.writeDouble(self.netCollection)
21440 
      oprot.writeFieldEnd()
21441 
    oprot.writeFieldStop()
21442 
    oprot.writeStructEnd()
21443 
 
21444 
  def validate(self):
21445 
    return
21446 
 
21447 
 
21448 
  def __repr__(self):
21449 
    L = ['%s=%r' % (key, value)
21450 
      for key, value in self.__dict__.iteritems()]
21451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21452 
 
21453 
  def __eq__(self, other):
21454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21455 
 
21456 
  def __ne__(self, other):
21457 
    return not (self == other)
21458 
 
21459 
class savePaymentSettlements_result:
21460 
  """
21461 
  Attributes:
21462 
   - ex
21463 
  """
21464 
 
21465 
  thrift_spec = (
21466 
    None, # 0
21467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21468 
  )
21469 
 
21470 
  def __init__(self, ex=None,):
21471 
    self.ex = ex
21472 
 
21473 
  def read(self, iprot):
21474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21476 
      return
21477 
    iprot.readStructBegin()
21478 
    while True:
21479 
      (fname, ftype, fid) = iprot.readFieldBegin()
21480 
      if ftype == TType.STOP:
21481 
        break
21482 
      if fid == 1:
21483 
        if ftype == TType.STRUCT:
21484 
          self.ex = TransactionServiceException()
21485 
          self.ex.read(iprot)
21486 
        else:
21487 
          iprot.skip(ftype)
21488 
      else:
21489 
        iprot.skip(ftype)
21490 
      iprot.readFieldEnd()
21491 
    iprot.readStructEnd()
21492 
 
21493 
  def write(self, oprot):
21494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21496 
      return
21497 
    oprot.writeStructBegin('savePaymentSettlements_result')
21498 
    if self.ex is not None:
21499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21500 
      self.ex.write(oprot)
21501 
      oprot.writeFieldEnd()
21502 
    oprot.writeFieldStop()
21503 
    oprot.writeStructEnd()
21504 
 
21505 
  def validate(self):
21506 
    return
21507 
 
21508 
 
21509 
  def __repr__(self):
21510 
    L = ['%s=%r' % (key, value)
21511 
      for key, value in self.__dict__.iteritems()]
21512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21513 
 
21514 
  def __eq__(self, other):
21515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21516 
 
21517 
  def __ne__(self, other):
21518 
    return not (self == other)
21519 
 
21520 
class saveEBSSettlementSummary_args:
21521 
  """
21522 
  Attributes:
21523 
   - settlementId
21524 
   - settlementDate
21525 
   - transactionDateFrom
21526 
   - transactionDateTo
21527 
   - amount
21528 
  """
21529 
 
21530 
  thrift_spec = (
21531 
    None, # 0
21532 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21533 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21534 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21535 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21536 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21537 
  )
21538 
 
21539 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21540 
    self.settlementId = settlementId
21541 
    self.settlementDate = settlementDate
21542 
    self.transactionDateFrom = transactionDateFrom
21543 
    self.transactionDateTo = transactionDateTo
21544 
    self.amount = amount
21545 
 
21546 
  def read(self, iprot):
21547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21549 
      return
21550 
    iprot.readStructBegin()
21551 
    while True:
21552 
      (fname, ftype, fid) = iprot.readFieldBegin()
21553 
      if ftype == TType.STOP:
21554 
        break
21555 
      if fid == 1:
21556 
        if ftype == TType.I64:
21557 
          self.settlementId = iprot.readI64();
21558 
        else:
21559 
          iprot.skip(ftype)
21560 
      elif fid == 2:
21561 
        if ftype == TType.I64:
21562 
          self.settlementDate = iprot.readI64();
21563 
        else:
21564 
          iprot.skip(ftype)
21565 
      elif fid == 3:
21566 
        if ftype == TType.I64:
21567 
          self.transactionDateFrom = iprot.readI64();
21568 
        else:
21569 
          iprot.skip(ftype)
21570 
      elif fid == 4:
21571 
        if ftype == TType.I64:
21572 
          self.transactionDateTo = iprot.readI64();
21573 
        else:
21574 
          iprot.skip(ftype)
21575 
      elif fid == 5:
21576 
        if ftype == TType.DOUBLE:
21577 
          self.amount = iprot.readDouble();
21578 
        else:
21579 
          iprot.skip(ftype)
21580 
      else:
21581 
        iprot.skip(ftype)
21582 
      iprot.readFieldEnd()
21583 
    iprot.readStructEnd()
21584 
 
21585 
  def write(self, oprot):
21586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21588 
      return
21589 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21590 
    if self.settlementId is not None:
21591 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21592 
      oprot.writeI64(self.settlementId)
21593 
      oprot.writeFieldEnd()
21594 
    if self.settlementDate is not None:
21595 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21596 
      oprot.writeI64(self.settlementDate)
21597 
      oprot.writeFieldEnd()
21598 
    if self.transactionDateFrom is not None:
21599 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21600 
      oprot.writeI64(self.transactionDateFrom)
21601 
      oprot.writeFieldEnd()
21602 
    if self.transactionDateTo is not None:
21603 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21604 
      oprot.writeI64(self.transactionDateTo)
21605 
      oprot.writeFieldEnd()
21606 
    if self.amount is not None:
21607 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21608 
      oprot.writeDouble(self.amount)
21609 
      oprot.writeFieldEnd()
21610 
    oprot.writeFieldStop()
21611 
    oprot.writeStructEnd()
21612 
 
21613 
  def validate(self):
21614 
    return
21615 
 
21616 
 
21617 
  def __repr__(self):
21618 
    L = ['%s=%r' % (key, value)
21619 
      for key, value in self.__dict__.iteritems()]
21620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21621 
 
21622 
  def __eq__(self, other):
21623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21624 
 
21625 
  def __ne__(self, other):
21626 
    return not (self == other)
21627 
 
21628 
class saveEBSSettlementSummary_result:
21629 
  """
21630 
  Attributes:
21631 
   - ex
21632 
  """
21633 
 
21634 
  thrift_spec = (
21635 
    None, # 0
21636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21637 
  )
21638 
 
21639 
  def __init__(self, ex=None,):
21640 
    self.ex = ex
21641 
 
21642 
  def read(self, iprot):
21643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21645 
      return
21646 
    iprot.readStructBegin()
21647 
    while True:
21648 
      (fname, ftype, fid) = iprot.readFieldBegin()
21649 
      if ftype == TType.STOP:
21650 
        break
21651 
      if fid == 1:
21652 
        if ftype == TType.STRUCT:
21653 
          self.ex = TransactionServiceException()
21654 
          self.ex.read(iprot)
21655 
        else:
21656 
          iprot.skip(ftype)
21657 
      else:
21658 
        iprot.skip(ftype)
21659 
      iprot.readFieldEnd()
21660 
    iprot.readStructEnd()
21661 
 
21662 
  def write(self, oprot):
21663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21665 
      return
21666 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
21667 
    if self.ex is not None:
21668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21669 
      self.ex.write(oprot)
21670 
      oprot.writeFieldEnd()
21671 
    oprot.writeFieldStop()
21672 
    oprot.writeStructEnd()
21673 
 
21674 
  def validate(self):
21675 
    return
21676 
 
21677 
 
21678 
  def __repr__(self):
21679 
    L = ['%s=%r' % (key, value)
21680 
      for key, value in self.__dict__.iteritems()]
21681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21682 
 
21683 
  def __eq__(self, other):
21684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21685 
 
21686 
  def __ne__(self, other):
21687 
    return not (self == other)
21688 
 
5386 phani.kuma 21689 
class getSettlementForPrepaid_args:
4600 varun.gupt 21690 
  """
21691 
  Attributes:
5189 varun.gupt 21692 
   - referenceId
21693 
   - isRefund
4600 varun.gupt 21694 
  """
21695 
 
21696 
  thrift_spec = (
21697 
    None, # 0
5189 varun.gupt 21698 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21699 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21700 
  )
21701 
 
5386 phani.kuma 21702 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21703 
    self.referenceId = referenceId
21704 
    self.isRefund = isRefund
4600 varun.gupt 21705 
 
21706 
  def read(self, iprot):
21707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21709 
      return
21710 
    iprot.readStructBegin()
21711 
    while True:
21712 
      (fname, ftype, fid) = iprot.readFieldBegin()
21713 
      if ftype == TType.STOP:
21714 
        break
21715 
      if fid == 1:
21716 
        if ftype == TType.I64:
5189 varun.gupt 21717 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21718 
        else:
21719 
          iprot.skip(ftype)
5189 varun.gupt 21720 
      elif fid == 2:
21721 
        if ftype == TType.BOOL:
21722 
          self.isRefund = iprot.readBool();
21723 
        else:
21724 
          iprot.skip(ftype)
4600 varun.gupt 21725 
      else:
21726 
        iprot.skip(ftype)
21727 
      iprot.readFieldEnd()
21728 
    iprot.readStructEnd()
21729 
 
21730 
  def write(self, oprot):
21731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21733 
      return
5386 phani.kuma 21734 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21735 
    if self.referenceId is not None:
21736 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
21737 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21738 
      oprot.writeFieldEnd()
5386 phani.kuma 21739 
    if self.isRefund is not None:
21740 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
21741 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 21742 
      oprot.writeFieldEnd()
5386 phani.kuma 21743 
    oprot.writeFieldStop()
21744 
    oprot.writeStructEnd()
21745 
 
21746 
  def validate(self):
21747 
    return
21748 
 
21749 
 
21750 
  def __repr__(self):
21751 
    L = ['%s=%r' % (key, value)
21752 
      for key, value in self.__dict__.iteritems()]
21753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21754 
 
21755 
  def __eq__(self, other):
21756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21757 
 
21758 
  def __ne__(self, other):
21759 
    return not (self == other)
21760 
 
21761 
class getSettlementForPrepaid_result:
21762 
  """
21763 
  Attributes:
21764 
   - success
21765 
   - ex
21766 
  """
21767 
 
21768 
  thrift_spec = (
21769 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21770 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21771 
  )
21772 
 
21773 
  def __init__(self, success=None, ex=None,):
21774 
    self.success = success
21775 
    self.ex = ex
21776 
 
21777 
  def read(self, iprot):
21778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21780 
      return
21781 
    iprot.readStructBegin()
21782 
    while True:
21783 
      (fname, ftype, fid) = iprot.readFieldBegin()
21784 
      if ftype == TType.STOP:
21785 
        break
21786 
      if fid == 0:
21787 
        if ftype == TType.STRUCT:
21788 
          self.success = PaymentSettlement()
21789 
          self.success.read(iprot)
21790 
        else:
21791 
          iprot.skip(ftype)
21792 
      elif fid == 1:
21793 
        if ftype == TType.STRUCT:
21794 
          self.ex = TransactionServiceException()
21795 
          self.ex.read(iprot)
21796 
        else:
21797 
          iprot.skip(ftype)
21798 
      else:
21799 
        iprot.skip(ftype)
21800 
      iprot.readFieldEnd()
21801 
    iprot.readStructEnd()
21802 
 
21803 
  def write(self, oprot):
21804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21806 
      return
21807 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21808 
    if self.success is not None:
21809 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21810 
      self.success.write(oprot)
21811 
      oprot.writeFieldEnd()
21812 
    if self.ex is not None:
21813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21814 
      self.ex.write(oprot)
21815 
      oprot.writeFieldEnd()
21816 
    oprot.writeFieldStop()
21817 
    oprot.writeStructEnd()
21818 
 
21819 
  def validate(self):
21820 
    return
21821 
 
21822 
 
21823 
  def __repr__(self):
21824 
    L = ['%s=%r' % (key, value)
21825 
      for key, value in self.__dict__.iteritems()]
21826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21827 
 
21828 
  def __eq__(self, other):
21829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21830 
 
21831 
  def __ne__(self, other):
21832 
    return not (self == other)
21833 
 
21834 
class getSettlementForCod_args:
21835 
  """
21836 
  Attributes:
21837 
   - orderId
21838 
   - isRefund
21839 
  """
21840 
 
21841 
  thrift_spec = (
21842 
    None, # 0
21843 
    (1, TType.I64, 'orderId', None, None, ), # 1
21844 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21845 
  )
21846 
 
21847 
  def __init__(self, orderId=None, isRefund=None,):
21848 
    self.orderId = orderId
21849 
    self.isRefund = isRefund
21850 
 
21851 
  def read(self, iprot):
21852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21854 
      return
21855 
    iprot.readStructBegin()
21856 
    while True:
21857 
      (fname, ftype, fid) = iprot.readFieldBegin()
21858 
      if ftype == TType.STOP:
21859 
        break
21860 
      if fid == 1:
21861 
        if ftype == TType.I64:
21862 
          self.orderId = iprot.readI64();
21863 
        else:
21864 
          iprot.skip(ftype)
21865 
      elif fid == 2:
21866 
        if ftype == TType.BOOL:
21867 
          self.isRefund = iprot.readBool();
21868 
        else:
21869 
          iprot.skip(ftype)
21870 
      else:
21871 
        iprot.skip(ftype)
21872 
      iprot.readFieldEnd()
21873 
    iprot.readStructEnd()
21874 
 
21875 
  def write(self, oprot):
21876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21878 
      return
21879 
    oprot.writeStructBegin('getSettlementForCod_args')
21880 
    if self.orderId is not None:
21881 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21882 
      oprot.writeI64(self.orderId)
21883 
      oprot.writeFieldEnd()
5189 varun.gupt 21884 
    if self.isRefund is not None:
5386 phani.kuma 21885 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21886 
      oprot.writeBool(self.isRefund)
21887 
      oprot.writeFieldEnd()
4600 varun.gupt 21888 
    oprot.writeFieldStop()
21889 
    oprot.writeStructEnd()
21890 
 
21891 
  def validate(self):
21892 
    return
21893 
 
21894 
 
21895 
  def __repr__(self):
21896 
    L = ['%s=%r' % (key, value)
21897 
      for key, value in self.__dict__.iteritems()]
21898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21899 
 
21900 
  def __eq__(self, other):
21901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21902 
 
21903 
  def __ne__(self, other):
21904 
    return not (self == other)
21905 
 
5386 phani.kuma 21906 
class getSettlementForCod_result:
4600 varun.gupt 21907 
  """
21908 
  Attributes:
21909 
   - success
21910 
   - ex
21911 
  """
21912 
 
21913 
  thrift_spec = (
21914 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21916 
  )
21917 
 
21918 
  def __init__(self, success=None, ex=None,):
21919 
    self.success = success
21920 
    self.ex = ex
21921 
 
21922 
  def read(self, iprot):
21923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21925 
      return
21926 
    iprot.readStructBegin()
21927 
    while True:
21928 
      (fname, ftype, fid) = iprot.readFieldBegin()
21929 
      if ftype == TType.STOP:
21930 
        break
21931 
      if fid == 0:
21932 
        if ftype == TType.STRUCT:
21933 
          self.success = PaymentSettlement()
21934 
          self.success.read(iprot)
21935 
        else:
21936 
          iprot.skip(ftype)
21937 
      elif fid == 1:
21938 
        if ftype == TType.STRUCT:
21939 
          self.ex = TransactionServiceException()
21940 
          self.ex.read(iprot)
21941 
        else:
21942 
          iprot.skip(ftype)
21943 
      else:
21944 
        iprot.skip(ftype)
21945 
      iprot.readFieldEnd()
21946 
    iprot.readStructEnd()
21947 
 
21948 
  def write(self, oprot):
21949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21951 
      return
5386 phani.kuma 21952 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21953 
    if self.success is not None:
21954 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21955 
      self.success.write(oprot)
21956 
      oprot.writeFieldEnd()
21957 
    if self.ex is not None:
21958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21959 
      self.ex.write(oprot)
21960 
      oprot.writeFieldEnd()
21961 
    oprot.writeFieldStop()
21962 
    oprot.writeStructEnd()
21963 
 
21964 
  def validate(self):
21965 
    return
21966 
 
21967 
 
21968 
  def __repr__(self):
21969 
    L = ['%s=%r' % (key, value)
21970 
      for key, value in self.__dict__.iteritems()]
21971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21972 
 
21973 
  def __eq__(self, other):
21974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21975 
 
21976 
  def __ne__(self, other):
21977 
    return not (self == other)
21978 
 
21979 
class getEBSSettlementSummaries_args:
21980 
 
21981 
  thrift_spec = (
21982 
  )
21983 
 
21984 
  def read(self, iprot):
21985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21987 
      return
21988 
    iprot.readStructBegin()
21989 
    while True:
21990 
      (fname, ftype, fid) = iprot.readFieldBegin()
21991 
      if ftype == TType.STOP:
21992 
        break
21993 
      else:
21994 
        iprot.skip(ftype)
21995 
      iprot.readFieldEnd()
21996 
    iprot.readStructEnd()
21997 
 
21998 
  def write(self, oprot):
21999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22001 
      return
22002 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22003 
    oprot.writeFieldStop()
22004 
    oprot.writeStructEnd()
22005 
 
22006 
  def validate(self):
22007 
    return
22008 
 
22009 
 
22010 
  def __repr__(self):
22011 
    L = ['%s=%r' % (key, value)
22012 
      for key, value in self.__dict__.iteritems()]
22013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22014 
 
22015 
  def __eq__(self, other):
22016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22017 
 
22018 
  def __ne__(self, other):
22019 
    return not (self == other)
22020 
 
22021 
class getEBSSettlementSummaries_result:
22022 
  """
22023 
  Attributes:
22024 
   - success
22025 
   - ex
22026 
  """
22027 
 
22028 
  thrift_spec = (
22029 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22031 
  )
22032 
 
22033 
  def __init__(self, success=None, ex=None,):
22034 
    self.success = success
22035 
    self.ex = ex
22036 
 
22037 
  def read(self, iprot):
22038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22040 
      return
22041 
    iprot.readStructBegin()
22042 
    while True:
22043 
      (fname, ftype, fid) = iprot.readFieldBegin()
22044 
      if ftype == TType.STOP:
22045 
        break
22046 
      if fid == 0:
22047 
        if ftype == TType.MAP:
22048 
          self.success = {}
5481 phani.kuma 22049 
          (_ktype498, _vtype499, _size497 ) = iprot.readMapBegin()
22050 
          for _i501 in xrange(_size497):
22051 
            _key502 = iprot.readI64();
22052 
            _val503 = iprot.readString();
22053 
            self.success[_key502] = _val503
4600 varun.gupt 22054 
          iprot.readMapEnd()
22055 
        else:
22056 
          iprot.skip(ftype)
22057 
      elif fid == 1:
22058 
        if ftype == TType.STRUCT:
22059 
          self.ex = TransactionServiceException()
22060 
          self.ex.read(iprot)
22061 
        else:
22062 
          iprot.skip(ftype)
22063 
      else:
22064 
        iprot.skip(ftype)
22065 
      iprot.readFieldEnd()
22066 
    iprot.readStructEnd()
22067 
 
22068 
  def write(self, oprot):
22069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22071 
      return
22072 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22073 
    if self.success is not None:
22074 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22075 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5481 phani.kuma 22076 
      for kiter504,viter505 in self.success.items():
22077 
        oprot.writeI64(kiter504)
22078 
        oprot.writeString(viter505)
4600 varun.gupt 22079 
      oprot.writeMapEnd()
22080 
      oprot.writeFieldEnd()
22081 
    if self.ex is not None:
22082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22083 
      self.ex.write(oprot)
22084 
      oprot.writeFieldEnd()
22085 
    oprot.writeFieldStop()
22086 
    oprot.writeStructEnd()
22087 
 
22088 
  def validate(self):
22089 
    return
22090 
 
22091 
 
22092 
  def __repr__(self):
22093 
    L = ['%s=%r' % (key, value)
22094 
      for key, value in self.__dict__.iteritems()]
22095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22096 
 
22097 
  def __eq__(self, other):
22098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22099 
 
22100 
  def __ne__(self, other):
22101 
    return not (self == other)
22102 
 
22103 
class markEBSSettlementUploaded_args:
22104 
  """
22105 
  Attributes:
22106 
   - settlementId
22107 
  """
22108 
 
22109 
  thrift_spec = (
22110 
    None, # 0
22111 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22112 
  )
22113 
 
22114 
  def __init__(self, settlementId=None,):
22115 
    self.settlementId = settlementId
22116 
 
22117 
  def read(self, iprot):
22118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22120 
      return
22121 
    iprot.readStructBegin()
22122 
    while True:
22123 
      (fname, ftype, fid) = iprot.readFieldBegin()
22124 
      if ftype == TType.STOP:
22125 
        break
22126 
      if fid == 1:
22127 
        if ftype == TType.I64:
22128 
          self.settlementId = iprot.readI64();
22129 
        else:
22130 
          iprot.skip(ftype)
22131 
      else:
22132 
        iprot.skip(ftype)
22133 
      iprot.readFieldEnd()
22134 
    iprot.readStructEnd()
22135 
 
22136 
  def write(self, oprot):
22137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22139 
      return
22140 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22141 
    if self.settlementId is not None:
22142 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22143 
      oprot.writeI64(self.settlementId)
22144 
      oprot.writeFieldEnd()
22145 
    oprot.writeFieldStop()
22146 
    oprot.writeStructEnd()
22147 
 
22148 
  def validate(self):
22149 
    return
22150 
 
22151 
 
22152 
  def __repr__(self):
22153 
    L = ['%s=%r' % (key, value)
22154 
      for key, value in self.__dict__.iteritems()]
22155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22156 
 
22157 
  def __eq__(self, other):
22158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22159 
 
22160 
  def __ne__(self, other):
22161 
    return not (self == other)
22162 
 
22163 
class markEBSSettlementUploaded_result:
22164 
  """
22165 
  Attributes:
22166 
   - ex
22167 
  """
22168 
 
22169 
  thrift_spec = (
22170 
    None, # 0
22171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22172 
  )
22173 
 
22174 
  def __init__(self, ex=None,):
22175 
    self.ex = ex
22176 
 
22177 
  def read(self, iprot):
22178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22180 
      return
22181 
    iprot.readStructBegin()
22182 
    while True:
22183 
      (fname, ftype, fid) = iprot.readFieldBegin()
22184 
      if ftype == TType.STOP:
22185 
        break
22186 
      if fid == 1:
22187 
        if ftype == TType.STRUCT:
22188 
          self.ex = TransactionServiceException()
22189 
          self.ex.read(iprot)
22190 
        else:
22191 
          iprot.skip(ftype)
22192 
      else:
22193 
        iprot.skip(ftype)
22194 
      iprot.readFieldEnd()
22195 
    iprot.readStructEnd()
22196 
 
22197 
  def write(self, oprot):
22198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22200 
      return
22201 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22202 
    if self.ex is not None:
22203 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22204 
      self.ex.write(oprot)
22205 
      oprot.writeFieldEnd()
22206 
    oprot.writeFieldStop()
22207 
    oprot.writeStructEnd()
22208 
 
22209 
  def validate(self):
22210 
    return
22211 
 
22212 
 
22213 
  def __repr__(self):
22214 
    L = ['%s=%r' % (key, value)
22215 
      for key, value in self.__dict__.iteritems()]
22216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22217 
 
22218 
  def __eq__(self, other):
22219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22220 
 
22221 
  def __ne__(self, other):
22222 
    return not (self == other)
22223 
 
22224 
class getEBSSettlementDate_args:
22225 
  """
22226 
  Attributes:
22227 
   - settlementId
22228 
  """
22229 
 
22230 
  thrift_spec = (
22231 
    None, # 0
22232 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22233 
  )
22234 
 
22235 
  def __init__(self, settlementId=None,):
22236 
    self.settlementId = settlementId
22237 
 
22238 
  def read(self, iprot):
22239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22241 
      return
22242 
    iprot.readStructBegin()
22243 
    while True:
22244 
      (fname, ftype, fid) = iprot.readFieldBegin()
22245 
      if ftype == TType.STOP:
22246 
        break
22247 
      if fid == 1:
22248 
        if ftype == TType.I64:
22249 
          self.settlementId = iprot.readI64();
22250 
        else:
22251 
          iprot.skip(ftype)
22252 
      else:
22253 
        iprot.skip(ftype)
22254 
      iprot.readFieldEnd()
22255 
    iprot.readStructEnd()
22256 
 
22257 
  def write(self, oprot):
22258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22260 
      return
22261 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22262 
    if self.settlementId is not None:
22263 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22264 
      oprot.writeI64(self.settlementId)
22265 
      oprot.writeFieldEnd()
22266 
    oprot.writeFieldStop()
22267 
    oprot.writeStructEnd()
22268 
 
22269 
  def validate(self):
22270 
    return
22271 
 
22272 
 
22273 
  def __repr__(self):
22274 
    L = ['%s=%r' % (key, value)
22275 
      for key, value in self.__dict__.iteritems()]
22276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22277 
 
22278 
  def __eq__(self, other):
22279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22280 
 
22281 
  def __ne__(self, other):
22282 
    return not (self == other)
22283 
 
22284 
class getEBSSettlementDate_result:
22285 
  """
22286 
  Attributes:
22287 
   - success
22288 
   - ex
22289 
  """
22290 
 
22291 
  thrift_spec = (
22292 
    (0, TType.I64, 'success', None, None, ), # 0
22293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22294 
  )
22295 
 
22296 
  def __init__(self, success=None, ex=None,):
22297 
    self.success = success
22298 
    self.ex = ex
22299 
 
22300 
  def read(self, iprot):
22301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22303 
      return
22304 
    iprot.readStructBegin()
22305 
    while True:
22306 
      (fname, ftype, fid) = iprot.readFieldBegin()
22307 
      if ftype == TType.STOP:
22308 
        break
22309 
      if fid == 0:
22310 
        if ftype == TType.I64:
22311 
          self.success = iprot.readI64();
22312 
        else:
22313 
          iprot.skip(ftype)
22314 
      elif fid == 1:
22315 
        if ftype == TType.STRUCT:
22316 
          self.ex = TransactionServiceException()
22317 
          self.ex.read(iprot)
22318 
        else:
22319 
          iprot.skip(ftype)
22320 
      else:
22321 
        iprot.skip(ftype)
22322 
      iprot.readFieldEnd()
22323 
    iprot.readStructEnd()
22324 
 
22325 
  def write(self, oprot):
22326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22328 
      return
22329 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22330 
    if self.success is not None:
22331 
      oprot.writeFieldBegin('success', TType.I64, 0)
22332 
      oprot.writeI64(self.success)
22333 
      oprot.writeFieldEnd()
22334 
    if self.ex is not None:
22335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22336 
      self.ex.write(oprot)
22337 
      oprot.writeFieldEnd()
22338 
    oprot.writeFieldStop()
22339 
    oprot.writeStructEnd()
22340 
 
22341 
  def validate(self):
22342 
    return
22343 
 
22344 
 
22345 
  def __repr__(self):
22346 
    L = ['%s=%r' % (key, value)
22347 
      for key, value in self.__dict__.iteritems()]
22348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22349 
 
22350 
  def __eq__(self, other):
22351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22352 
 
22353 
  def __ne__(self, other):
22354 
    return not (self == other)
4715 varun.gupt 22355 
 
22356 
class getSettlementsByDate_args:
22357 
  """
22358 
  Attributes:
22359 
   - settlementDateFrom
22360 
   - settlementDateTo
22361 
   - isRefund
22362 
  """
22363 
 
22364 
  thrift_spec = (
22365 
    None, # 0
22366 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22367 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22368 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22369 
  )
22370 
 
22371 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22372 
    self.settlementDateFrom = settlementDateFrom
22373 
    self.settlementDateTo = settlementDateTo
22374 
    self.isRefund = isRefund
22375 
 
22376 
  def read(self, iprot):
22377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22379 
      return
22380 
    iprot.readStructBegin()
22381 
    while True:
22382 
      (fname, ftype, fid) = iprot.readFieldBegin()
22383 
      if ftype == TType.STOP:
22384 
        break
22385 
      if fid == 1:
22386 
        if ftype == TType.I64:
22387 
          self.settlementDateFrom = iprot.readI64();
22388 
        else:
22389 
          iprot.skip(ftype)
22390 
      elif fid == 2:
22391 
        if ftype == TType.I64:
22392 
          self.settlementDateTo = iprot.readI64();
22393 
        else:
22394 
          iprot.skip(ftype)
22395 
      elif fid == 3:
22396 
        if ftype == TType.BOOL:
22397 
          self.isRefund = iprot.readBool();
22398 
        else:
22399 
          iprot.skip(ftype)
22400 
      else:
22401 
        iprot.skip(ftype)
22402 
      iprot.readFieldEnd()
22403 
    iprot.readStructEnd()
22404 
 
22405 
  def write(self, oprot):
22406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22408 
      return
22409 
    oprot.writeStructBegin('getSettlementsByDate_args')
22410 
    if self.settlementDateFrom is not None:
22411 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22412 
      oprot.writeI64(self.settlementDateFrom)
22413 
      oprot.writeFieldEnd()
22414 
    if self.settlementDateTo is not None:
22415 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22416 
      oprot.writeI64(self.settlementDateTo)
22417 
      oprot.writeFieldEnd()
22418 
    if self.isRefund is not None:
22419 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22420 
      oprot.writeBool(self.isRefund)
22421 
      oprot.writeFieldEnd()
22422 
    oprot.writeFieldStop()
22423 
    oprot.writeStructEnd()
22424 
 
22425 
  def validate(self):
22426 
    return
22427 
 
22428 
 
22429 
  def __repr__(self):
22430 
    L = ['%s=%r' % (key, value)
22431 
      for key, value in self.__dict__.iteritems()]
22432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22433 
 
22434 
  def __eq__(self, other):
22435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22436 
 
22437 
  def __ne__(self, other):
22438 
    return not (self == other)
22439 
 
22440 
class getSettlementsByDate_result:
22441 
  """
22442 
  Attributes:
22443 
   - success
22444 
   - ex
22445 
  """
22446 
 
22447 
  thrift_spec = (
22448 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22450 
  )
22451 
 
22452 
  def __init__(self, success=None, ex=None,):
22453 
    self.success = success
22454 
    self.ex = ex
22455 
 
22456 
  def read(self, iprot):
22457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22459 
      return
22460 
    iprot.readStructBegin()
22461 
    while True:
22462 
      (fname, ftype, fid) = iprot.readFieldBegin()
22463 
      if ftype == TType.STOP:
22464 
        break
22465 
      if fid == 0:
22466 
        if ftype == TType.LIST:
22467 
          self.success = []
5481 phani.kuma 22468 
          (_etype509, _size506) = iprot.readListBegin()
22469 
          for _i510 in xrange(_size506):
22470 
            _elem511 = PaymentSettlement()
22471 
            _elem511.read(iprot)
22472 
            self.success.append(_elem511)
4715 varun.gupt 22473 
          iprot.readListEnd()
22474 
        else:
22475 
          iprot.skip(ftype)
22476 
      elif fid == 1:
22477 
        if ftype == TType.STRUCT:
22478 
          self.ex = TransactionServiceException()
22479 
          self.ex.read(iprot)
22480 
        else:
22481 
          iprot.skip(ftype)
22482 
      else:
22483 
        iprot.skip(ftype)
22484 
      iprot.readFieldEnd()
22485 
    iprot.readStructEnd()
22486 
 
22487 
  def write(self, oprot):
22488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22490 
      return
22491 
    oprot.writeStructBegin('getSettlementsByDate_result')
22492 
    if self.success is not None:
22493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22495 
      for iter512 in self.success:
22496 
        iter512.write(oprot)
4715 varun.gupt 22497 
      oprot.writeListEnd()
22498 
      oprot.writeFieldEnd()
22499 
    if self.ex is not None:
22500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22501 
      self.ex.write(oprot)
22502 
      oprot.writeFieldEnd()
22503 
    oprot.writeFieldStop()
22504 
    oprot.writeStructEnd()
22505 
 
22506 
  def validate(self):
22507 
    return
22508 
 
22509 
 
22510 
  def __repr__(self):
22511 
    L = ['%s=%r' % (key, value)
22512 
      for key, value in self.__dict__.iteritems()]
22513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22514 
 
22515 
  def __eq__(self, other):
22516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22517 
 
22518 
  def __ne__(self, other):
22519 
    return not (self == other)
22520 
 
22521 
class getReshippedOrderIds_args:
22522 
  """
22523 
  Attributes:
22524 
   - orderIds
22525 
  """
22526 
 
22527 
  thrift_spec = (
22528 
    None, # 0
22529 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22530 
  )
22531 
 
22532 
  def __init__(self, orderIds=None,):
22533 
    self.orderIds = orderIds
22534 
 
22535 
  def read(self, iprot):
22536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22538 
      return
22539 
    iprot.readStructBegin()
22540 
    while True:
22541 
      (fname, ftype, fid) = iprot.readFieldBegin()
22542 
      if ftype == TType.STOP:
22543 
        break
22544 
      if fid == 1:
22545 
        if ftype == TType.LIST:
22546 
          self.orderIds = []
5481 phani.kuma 22547 
          (_etype516, _size513) = iprot.readListBegin()
22548 
          for _i517 in xrange(_size513):
22549 
            _elem518 = iprot.readI64();
22550 
            self.orderIds.append(_elem518)
4715 varun.gupt 22551 
          iprot.readListEnd()
22552 
        else:
22553 
          iprot.skip(ftype)
22554 
      else:
22555 
        iprot.skip(ftype)
22556 
      iprot.readFieldEnd()
22557 
    iprot.readStructEnd()
22558 
 
22559 
  def write(self, oprot):
22560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22562 
      return
22563 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22564 
    if self.orderIds is not None:
22565 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22566 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5481 phani.kuma 22567 
      for iter519 in self.orderIds:
22568 
        oprot.writeI64(iter519)
4715 varun.gupt 22569 
      oprot.writeListEnd()
22570 
      oprot.writeFieldEnd()
22571 
    oprot.writeFieldStop()
22572 
    oprot.writeStructEnd()
22573 
 
22574 
  def validate(self):
22575 
    return
22576 
 
22577 
 
22578 
  def __repr__(self):
22579 
    L = ['%s=%r' % (key, value)
22580 
      for key, value in self.__dict__.iteritems()]
22581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22582 
 
22583 
  def __eq__(self, other):
22584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22585 
 
22586 
  def __ne__(self, other):
22587 
    return not (self == other)
22588 
 
22589 
class getReshippedOrderIds_result:
22590 
  """
22591 
  Attributes:
22592 
   - success
22593 
   - ex
22594 
  """
22595 
 
22596 
  thrift_spec = (
22597 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22599 
  )
22600 
 
22601 
  def __init__(self, success=None, ex=None,):
22602 
    self.success = success
22603 
    self.ex = ex
22604 
 
22605 
  def read(self, iprot):
22606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22608 
      return
22609 
    iprot.readStructBegin()
22610 
    while True:
22611 
      (fname, ftype, fid) = iprot.readFieldBegin()
22612 
      if ftype == TType.STOP:
22613 
        break
22614 
      if fid == 0:
22615 
        if ftype == TType.LIST:
22616 
          self.success = []
5481 phani.kuma 22617 
          (_etype523, _size520) = iprot.readListBegin()
22618 
          for _i524 in xrange(_size520):
22619 
            _elem525 = iprot.readI64();
22620 
            self.success.append(_elem525)
4715 varun.gupt 22621 
          iprot.readListEnd()
22622 
        else:
22623 
          iprot.skip(ftype)
22624 
      elif fid == 1:
22625 
        if ftype == TType.STRUCT:
22626 
          self.ex = TransactionServiceException()
22627 
          self.ex.read(iprot)
22628 
        else:
22629 
          iprot.skip(ftype)
22630 
      else:
22631 
        iprot.skip(ftype)
22632 
      iprot.readFieldEnd()
22633 
    iprot.readStructEnd()
22634 
 
22635 
  def write(self, oprot):
22636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22638 
      return
22639 
    oprot.writeStructBegin('getReshippedOrderIds_result')
22640 
    if self.success is not None:
22641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22642 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22643 
      for iter526 in self.success:
22644 
        oprot.writeI64(iter526)
4715 varun.gupt 22645 
      oprot.writeListEnd()
22646 
      oprot.writeFieldEnd()
22647 
    if self.ex is not None:
22648 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22649 
      self.ex.write(oprot)
22650 
      oprot.writeFieldEnd()
22651 
    oprot.writeFieldStop()
22652 
    oprot.writeStructEnd()
22653 
 
22654 
  def validate(self):
22655 
    return
22656 
 
22657 
 
22658 
  def __repr__(self):
22659 
    L = ['%s=%r' % (key, value)
22660 
      for key, value in self.__dict__.iteritems()]
22661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22662 
 
22663 
  def __eq__(self, other):
22664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22665 
 
22666 
  def __ne__(self, other):
22667 
    return not (self == other)
4757 mandeep.dh 22668 
 
5481 phani.kuma 22669 
class getBilledOrders_args:
4875 varun.gupt 22670 
  """
22671 
  Attributes:
22672 
   - vendorId
5481 phani.kuma 22673 
   - onlyVendorNotPaid
22674 
   - billingDateFrom
22675 
   - billingDateTo
4875 varun.gupt 22676 
  """
22677 
 
22678 
  thrift_spec = (
22679 
    None, # 0
22680 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 22681 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
22682 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
22683 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 22684 
  )
22685 
 
5481 phani.kuma 22686 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 22687 
    self.vendorId = vendorId
5481 phani.kuma 22688 
    self.onlyVendorNotPaid = onlyVendorNotPaid
22689 
    self.billingDateFrom = billingDateFrom
22690 
    self.billingDateTo = billingDateTo
4875 varun.gupt 22691 
 
22692 
  def read(self, iprot):
22693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22695 
      return
22696 
    iprot.readStructBegin()
22697 
    while True:
22698 
      (fname, ftype, fid) = iprot.readFieldBegin()
22699 
      if ftype == TType.STOP:
22700 
        break
22701 
      if fid == 1:
22702 
        if ftype == TType.I64:
22703 
          self.vendorId = iprot.readI64();
22704 
        else:
22705 
          iprot.skip(ftype)
5481 phani.kuma 22706 
      elif fid == 2:
22707 
        if ftype == TType.BOOL:
22708 
          self.onlyVendorNotPaid = iprot.readBool();
22709 
        else:
22710 
          iprot.skip(ftype)
22711 
      elif fid == 3:
22712 
        if ftype == TType.I64:
22713 
          self.billingDateFrom = iprot.readI64();
22714 
        else:
22715 
          iprot.skip(ftype)
22716 
      elif fid == 4:
22717 
        if ftype == TType.I64:
22718 
          self.billingDateTo = iprot.readI64();
22719 
        else:
22720 
          iprot.skip(ftype)
4875 varun.gupt 22721 
      else:
22722 
        iprot.skip(ftype)
22723 
      iprot.readFieldEnd()
22724 
    iprot.readStructEnd()
22725 
 
22726 
  def write(self, oprot):
22727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22729 
      return
5481 phani.kuma 22730 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 22731 
    if self.vendorId is not None:
22732 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22733 
      oprot.writeI64(self.vendorId)
22734 
      oprot.writeFieldEnd()
5481 phani.kuma 22735 
    if self.onlyVendorNotPaid is not None:
22736 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
22737 
      oprot.writeBool(self.onlyVendorNotPaid)
22738 
      oprot.writeFieldEnd()
22739 
    if self.billingDateFrom is not None:
22740 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
22741 
      oprot.writeI64(self.billingDateFrom)
22742 
      oprot.writeFieldEnd()
22743 
    if self.billingDateTo is not None:
22744 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
22745 
      oprot.writeI64(self.billingDateTo)
22746 
      oprot.writeFieldEnd()
4875 varun.gupt 22747 
    oprot.writeFieldStop()
22748 
    oprot.writeStructEnd()
22749 
 
22750 
  def validate(self):
22751 
    return
22752 
 
22753 
 
22754 
  def __repr__(self):
22755 
    L = ['%s=%r' % (key, value)
22756 
      for key, value in self.__dict__.iteritems()]
22757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22758 
 
22759 
  def __eq__(self, other):
22760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22761 
 
22762 
  def __ne__(self, other):
22763 
    return not (self == other)
22764 
 
5481 phani.kuma 22765 
class getBilledOrders_result:
4875 varun.gupt 22766 
  """
22767 
  Attributes:
22768 
   - success
22769 
   - ex
22770 
  """
22771 
 
22772 
  thrift_spec = (
22773 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22775 
  )
22776 
 
22777 
  def __init__(self, success=None, ex=None,):
22778 
    self.success = success
22779 
    self.ex = ex
22780 
 
22781 
  def read(self, iprot):
22782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22784 
      return
22785 
    iprot.readStructBegin()
22786 
    while True:
22787 
      (fname, ftype, fid) = iprot.readFieldBegin()
22788 
      if ftype == TType.STOP:
22789 
        break
22790 
      if fid == 0:
22791 
        if ftype == TType.LIST:
22792 
          self.success = []
5481 phani.kuma 22793 
          (_etype530, _size527) = iprot.readListBegin()
22794 
          for _i531 in xrange(_size527):
22795 
            _elem532 = Order()
22796 
            _elem532.read(iprot)
22797 
            self.success.append(_elem532)
4875 varun.gupt 22798 
          iprot.readListEnd()
22799 
        else:
22800 
          iprot.skip(ftype)
22801 
      elif fid == 1:
22802 
        if ftype == TType.STRUCT:
22803 
          self.ex = TransactionServiceException()
22804 
          self.ex.read(iprot)
22805 
        else:
22806 
          iprot.skip(ftype)
22807 
      else:
22808 
        iprot.skip(ftype)
22809 
      iprot.readFieldEnd()
22810 
    iprot.readStructEnd()
22811 
 
22812 
  def write(self, oprot):
22813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22815 
      return
5481 phani.kuma 22816 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 22817 
    if self.success is not None:
22818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22820 
      for iter533 in self.success:
22821 
        iter533.write(oprot)
4875 varun.gupt 22822 
      oprot.writeListEnd()
22823 
      oprot.writeFieldEnd()
22824 
    if self.ex is not None:
22825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22826 
      self.ex.write(oprot)
22827 
      oprot.writeFieldEnd()
22828 
    oprot.writeFieldStop()
22829 
    oprot.writeStructEnd()
22830 
 
22831 
  def validate(self):
22832 
    return
22833 
 
22834 
 
22835 
  def __repr__(self):
22836 
    L = ['%s=%r' % (key, value)
22837 
      for key, value in self.__dict__.iteritems()]
22838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22839 
 
22840 
  def __eq__(self, other):
22841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22842 
 
22843 
  def __ne__(self, other):
22844 
    return not (self == other)
5031 varun.gupt 22845 
 
22846 
class getStatusDistributionOfOrders_args:
22847 
  """
22848 
  Attributes:
22849 
   - startDate
22850 
   - endDate
22851 
  """
22852 
 
22853 
  thrift_spec = (
22854 
    None, # 0
22855 
    (1, TType.I64, 'startDate', None, None, ), # 1
22856 
    (2, TType.I64, 'endDate', None, None, ), # 2
22857 
  )
22858 
 
22859 
  def __init__(self, startDate=None, endDate=None,):
22860 
    self.startDate = startDate
22861 
    self.endDate = endDate
22862 
 
22863 
  def read(self, iprot):
22864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22866 
      return
22867 
    iprot.readStructBegin()
22868 
    while True:
22869 
      (fname, ftype, fid) = iprot.readFieldBegin()
22870 
      if ftype == TType.STOP:
22871 
        break
22872 
      if fid == 1:
22873 
        if ftype == TType.I64:
22874 
          self.startDate = iprot.readI64();
22875 
        else:
22876 
          iprot.skip(ftype)
22877 
      elif fid == 2:
22878 
        if ftype == TType.I64:
22879 
          self.endDate = iprot.readI64();
22880 
        else:
22881 
          iprot.skip(ftype)
22882 
      else:
22883 
        iprot.skip(ftype)
22884 
      iprot.readFieldEnd()
22885 
    iprot.readStructEnd()
22886 
 
22887 
  def write(self, oprot):
22888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22890 
      return
22891 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22892 
    if self.startDate is not None:
22893 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22894 
      oprot.writeI64(self.startDate)
22895 
      oprot.writeFieldEnd()
22896 
    if self.endDate is not None:
22897 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22898 
      oprot.writeI64(self.endDate)
22899 
      oprot.writeFieldEnd()
22900 
    oprot.writeFieldStop()
22901 
    oprot.writeStructEnd()
22902 
 
22903 
  def validate(self):
22904 
    return
22905 
 
22906 
 
22907 
  def __repr__(self):
22908 
    L = ['%s=%r' % (key, value)
22909 
      for key, value in self.__dict__.iteritems()]
22910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22911 
 
22912 
  def __eq__(self, other):
22913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22914 
 
22915 
  def __ne__(self, other):
22916 
    return not (self == other)
22917 
 
22918 
class getStatusDistributionOfOrders_result:
22919 
  """
22920 
  Attributes:
22921 
   - success
22922 
   - ex
22923 
  """
22924 
 
22925 
  thrift_spec = (
22926 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22927 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22928 
  )
22929 
 
22930 
  def __init__(self, success=None, ex=None,):
22931 
    self.success = success
22932 
    self.ex = ex
22933 
 
22934 
  def read(self, iprot):
22935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22937 
      return
22938 
    iprot.readStructBegin()
22939 
    while True:
22940 
      (fname, ftype, fid) = iprot.readFieldBegin()
22941 
      if ftype == TType.STOP:
22942 
        break
22943 
      if fid == 0:
22944 
        if ftype == TType.MAP:
22945 
          self.success = {}
5481 phani.kuma 22946 
          (_ktype535, _vtype536, _size534 ) = iprot.readMapBegin()
22947 
          for _i538 in xrange(_size534):
22948 
            _key539 = iprot.readI64();
22949 
            _val540 = iprot.readI64();
22950 
            self.success[_key539] = _val540
5031 varun.gupt 22951 
          iprot.readMapEnd()
22952 
        else:
22953 
          iprot.skip(ftype)
22954 
      elif fid == 1:
22955 
        if ftype == TType.STRUCT:
22956 
          self.ex = TransactionServiceException()
22957 
          self.ex.read(iprot)
22958 
        else:
22959 
          iprot.skip(ftype)
22960 
      else:
22961 
        iprot.skip(ftype)
22962 
      iprot.readFieldEnd()
22963 
    iprot.readStructEnd()
22964 
 
22965 
  def write(self, oprot):
22966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22968 
      return
22969 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22970 
    if self.success is not None:
22971 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22972 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 22973 
      for kiter541,viter542 in self.success.items():
22974 
        oprot.writeI64(kiter541)
22975 
        oprot.writeI64(viter542)
5031 varun.gupt 22976 
      oprot.writeMapEnd()
22977 
      oprot.writeFieldEnd()
22978 
    if self.ex is not None:
22979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22980 
      self.ex.write(oprot)
22981 
      oprot.writeFieldEnd()
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
5067 varun.gupt 22999 
 
23000 
class getOrderIdsForStatus_args:
23001 
  """
23002 
  Attributes:
23003 
   - status
23004 
   - startDatetime
23005 
   - endDatetime
23006 
  """
23007 
 
23008 
  thrift_spec = (
23009 
    None, # 0
23010 
    (1, TType.I64, 'status', None, None, ), # 1
23011 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23012 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23013 
  )
23014 
 
23015 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23016 
    self.status = status
23017 
    self.startDatetime = startDatetime
23018 
    self.endDatetime = endDatetime
23019 
 
23020 
  def read(self, iprot):
23021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23023 
      return
23024 
    iprot.readStructBegin()
23025 
    while True:
23026 
      (fname, ftype, fid) = iprot.readFieldBegin()
23027 
      if ftype == TType.STOP:
23028 
        break
23029 
      if fid == 1:
23030 
        if ftype == TType.I64:
23031 
          self.status = iprot.readI64();
23032 
        else:
23033 
          iprot.skip(ftype)
23034 
      elif fid == 2:
23035 
        if ftype == TType.I64:
23036 
          self.startDatetime = iprot.readI64();
23037 
        else:
23038 
          iprot.skip(ftype)
23039 
      elif fid == 3:
23040 
        if ftype == TType.I64:
23041 
          self.endDatetime = iprot.readI64();
23042 
        else:
23043 
          iprot.skip(ftype)
23044 
      else:
23045 
        iprot.skip(ftype)
23046 
      iprot.readFieldEnd()
23047 
    iprot.readStructEnd()
23048 
 
23049 
  def write(self, oprot):
23050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23052 
      return
23053 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23054 
    if self.status is not None:
23055 
      oprot.writeFieldBegin('status', TType.I64, 1)
23056 
      oprot.writeI64(self.status)
23057 
      oprot.writeFieldEnd()
23058 
    if self.startDatetime is not None:
23059 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23060 
      oprot.writeI64(self.startDatetime)
23061 
      oprot.writeFieldEnd()
23062 
    if self.endDatetime is not None:
23063 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23064 
      oprot.writeI64(self.endDatetime)
23065 
      oprot.writeFieldEnd()
23066 
    oprot.writeFieldStop()
23067 
    oprot.writeStructEnd()
23068 
 
23069 
  def validate(self):
23070 
    return
23071 
 
23072 
 
23073 
  def __repr__(self):
23074 
    L = ['%s=%r' % (key, value)
23075 
      for key, value in self.__dict__.iteritems()]
23076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23077 
 
23078 
  def __eq__(self, other):
23079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23080 
 
23081 
  def __ne__(self, other):
23082 
    return not (self == other)
23083 
 
23084 
class getOrderIdsForStatus_result:
23085 
  """
23086 
  Attributes:
23087 
   - success
23088 
   - ex
23089 
  """
23090 
 
23091 
  thrift_spec = (
23092 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23094 
  )
23095 
 
23096 
  def __init__(self, success=None, ex=None,):
23097 
    self.success = success
23098 
    self.ex = ex
23099 
 
23100 
  def read(self, iprot):
23101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23103 
      return
23104 
    iprot.readStructBegin()
23105 
    while True:
23106 
      (fname, ftype, fid) = iprot.readFieldBegin()
23107 
      if ftype == TType.STOP:
23108 
        break
23109 
      if fid == 0:
23110 
        if ftype == TType.LIST:
23111 
          self.success = []
5481 phani.kuma 23112 
          (_etype546, _size543) = iprot.readListBegin()
23113 
          for _i547 in xrange(_size543):
23114 
            _elem548 = iprot.readI64();
23115 
            self.success.append(_elem548)
5067 varun.gupt 23116 
          iprot.readListEnd()
23117 
        else:
23118 
          iprot.skip(ftype)
23119 
      elif fid == 1:
23120 
        if ftype == TType.STRUCT:
23121 
          self.ex = TransactionServiceException()
23122 
          self.ex.read(iprot)
23123 
        else:
23124 
          iprot.skip(ftype)
23125 
      else:
23126 
        iprot.skip(ftype)
23127 
      iprot.readFieldEnd()
23128 
    iprot.readStructEnd()
23129 
 
23130 
  def write(self, oprot):
23131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23133 
      return
23134 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23135 
    if self.success is not None:
23136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23137 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 23138 
      for iter549 in self.success:
23139 
        oprot.writeI64(iter549)
5067 varun.gupt 23140 
      oprot.writeListEnd()
23141 
      oprot.writeFieldEnd()
23142 
    if self.ex is not None:
23143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23144 
      self.ex.write(oprot)
23145 
      oprot.writeFieldEnd()
23146 
    oprot.writeFieldStop()
23147 
    oprot.writeStructEnd()
23148 
 
23149 
  def validate(self):
23150 
    return
23151 
 
23152 
 
23153 
  def __repr__(self):
23154 
    L = ['%s=%r' % (key, value)
23155 
      for key, value in self.__dict__.iteritems()]
23156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23157 
 
23158 
  def __eq__(self, other):
23159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23160 
 
23161 
  def __ne__(self, other):
23162 
    return not (self == other)
5099 varun.gupt 23163 
 
5348 anupam.sin 23164 
class updateCODAgent_args:
23165 
  """
23166 
  Attributes:
23167 
   - agent
23168 
   - orderId
23169 
  """
23170 
 
23171 
  thrift_spec = (
23172 
    None, # 0
23173 
    (1, TType.STRING, 'agent', None, None, ), # 1
23174 
    (2, TType.I64, 'orderId', None, None, ), # 2
23175 
  )
23176 
 
23177 
  def __init__(self, agent=None, orderId=None,):
23178 
    self.agent = agent
23179 
    self.orderId = orderId
23180 
 
23181 
  def read(self, iprot):
23182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23184 
      return
23185 
    iprot.readStructBegin()
23186 
    while True:
23187 
      (fname, ftype, fid) = iprot.readFieldBegin()
23188 
      if ftype == TType.STOP:
23189 
        break
23190 
      if fid == 1:
23191 
        if ftype == TType.STRING:
23192 
          self.agent = iprot.readString();
23193 
        else:
23194 
          iprot.skip(ftype)
23195 
      elif fid == 2:
23196 
        if ftype == TType.I64:
23197 
          self.orderId = iprot.readI64();
23198 
        else:
23199 
          iprot.skip(ftype)
23200 
      else:
23201 
        iprot.skip(ftype)
23202 
      iprot.readFieldEnd()
23203 
    iprot.readStructEnd()
23204 
 
23205 
  def write(self, oprot):
23206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23208 
      return
23209 
    oprot.writeStructBegin('updateCODAgent_args')
23210 
    if self.agent is not None:
23211 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23212 
      oprot.writeString(self.agent)
23213 
      oprot.writeFieldEnd()
23214 
    if self.orderId is not None:
23215 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23216 
      oprot.writeI64(self.orderId)
23217 
      oprot.writeFieldEnd()
23218 
    oprot.writeFieldStop()
23219 
    oprot.writeStructEnd()
23220 
 
23221 
  def validate(self):
23222 
    return
23223 
 
23224 
 
23225 
  def __repr__(self):
23226 
    L = ['%s=%r' % (key, value)
23227 
      for key, value in self.__dict__.iteritems()]
23228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23229 
 
23230 
  def __eq__(self, other):
23231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23232 
 
23233 
  def __ne__(self, other):
23234 
    return not (self == other)
23235 
 
23236 
class updateCODAgent_result:
23237 
  """
23238 
  Attributes:
23239 
   - ex
23240 
  """
23241 
 
23242 
  thrift_spec = (
23243 
    None, # 0
23244 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23245 
  )
23246 
 
23247 
  def __init__(self, ex=None,):
23248 
    self.ex = ex
23249 
 
23250 
  def read(self, iprot):
23251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23253 
      return
23254 
    iprot.readStructBegin()
23255 
    while True:
23256 
      (fname, ftype, fid) = iprot.readFieldBegin()
23257 
      if ftype == TType.STOP:
23258 
        break
23259 
      if fid == 1:
23260 
        if ftype == TType.STRUCT:
23261 
          self.ex = TransactionServiceException()
23262 
          self.ex.read(iprot)
23263 
        else:
23264 
          iprot.skip(ftype)
23265 
      else:
23266 
        iprot.skip(ftype)
23267 
      iprot.readFieldEnd()
23268 
    iprot.readStructEnd()
23269 
 
23270 
  def write(self, oprot):
23271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23273 
      return
23274 
    oprot.writeStructBegin('updateCODAgent_result')
23275 
    if self.ex is not None:
23276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23277 
      self.ex.write(oprot)
23278 
      oprot.writeFieldEnd()
23279 
    oprot.writeFieldStop()
23280 
    oprot.writeStructEnd()
23281 
 
23282 
  def validate(self):
23283 
    return
23284 
 
23285 
 
23286 
  def __repr__(self):
23287 
    L = ['%s=%r' % (key, value)
23288 
      for key, value in self.__dict__.iteritems()]
23289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23290 
 
23291 
  def __eq__(self, other):
23292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23293 
 
23294 
  def __ne__(self, other):
23295 
    return not (self == other)
23296 
 
5099 varun.gupt 23297 
class updateOrderAsPaidToVendor_args:
23298 
  """
23299 
  Attributes:
23300 
   - orderId
23301 
  """
23302 
 
23303 
  thrift_spec = (
23304 
    None, # 0
23305 
    (1, TType.I64, 'orderId', None, None, ), # 1
23306 
  )
23307 
 
23308 
  def __init__(self, orderId=None,):
23309 
    self.orderId = orderId
23310 
 
23311 
  def read(self, iprot):
23312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23314 
      return
23315 
    iprot.readStructBegin()
23316 
    while True:
23317 
      (fname, ftype, fid) = iprot.readFieldBegin()
23318 
      if ftype == TType.STOP:
23319 
        break
23320 
      if fid == 1:
23321 
        if ftype == TType.I64:
23322 
          self.orderId = iprot.readI64();
23323 
        else:
23324 
          iprot.skip(ftype)
23325 
      else:
23326 
        iprot.skip(ftype)
23327 
      iprot.readFieldEnd()
23328 
    iprot.readStructEnd()
23329 
 
23330 
  def write(self, oprot):
23331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23333 
      return
23334 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23335 
    if self.orderId is not None:
23336 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23337 
      oprot.writeI64(self.orderId)
23338 
      oprot.writeFieldEnd()
23339 
    oprot.writeFieldStop()
23340 
    oprot.writeStructEnd()
23341 
 
23342 
  def validate(self):
23343 
    return
23344 
 
23345 
 
23346 
  def __repr__(self):
23347 
    L = ['%s=%r' % (key, value)
23348 
      for key, value in self.__dict__.iteritems()]
23349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23350 
 
23351 
  def __eq__(self, other):
23352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23353 
 
23354 
  def __ne__(self, other):
23355 
    return not (self == other)
23356 
 
23357 
class updateOrderAsPaidToVendor_result:
23358 
  """
23359 
  Attributes:
23360 
   - ex
23361 
  """
23362 
 
23363 
  thrift_spec = (
23364 
    None, # 0
23365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23366 
  )
23367 
 
23368 
  def __init__(self, ex=None,):
23369 
    self.ex = ex
23370 
 
23371 
  def read(self, iprot):
23372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23374 
      return
23375 
    iprot.readStructBegin()
23376 
    while True:
23377 
      (fname, ftype, fid) = iprot.readFieldBegin()
23378 
      if ftype == TType.STOP:
23379 
        break
23380 
      if fid == 1:
23381 
        if ftype == TType.STRUCT:
23382 
          self.ex = TransactionServiceException()
23383 
          self.ex.read(iprot)
23384 
        else:
23385 
          iprot.skip(ftype)
23386 
      else:
23387 
        iprot.skip(ftype)
23388 
      iprot.readFieldEnd()
23389 
    iprot.readStructEnd()
23390 
 
23391 
  def write(self, oprot):
23392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23394 
      return
23395 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23396 
    if self.ex is not None:
23397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23398 
      self.ex.write(oprot)
23399 
      oprot.writeFieldEnd()
23400 
    oprot.writeFieldStop()
23401 
    oprot.writeStructEnd()
23402 
 
23403 
  def validate(self):
23404 
    return
23405 
 
23406 
 
23407 
  def __repr__(self):
23408 
    L = ['%s=%r' % (key, value)
23409 
      for key, value in self.__dict__.iteritems()]
23410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23411 
 
23412 
  def __eq__(self, other):
23413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23414 
 
23415 
  def __ne__(self, other):
23416 
    return not (self == other)
5208 varun.gupt 23417 
 
5386 phani.kuma 23418 
class updateOrderOnlyAsPaidToVendor_args:
23419 
  """
23420 
  Attributes:
23421 
   - orderId
23422 
  """
23423 
 
23424 
  thrift_spec = (
23425 
    None, # 0
23426 
    (1, TType.I64, 'orderId', None, None, ), # 1
23427 
  )
23428 
 
23429 
  def __init__(self, orderId=None,):
23430 
    self.orderId = orderId
23431 
 
23432 
  def read(self, iprot):
23433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23435 
      return
23436 
    iprot.readStructBegin()
23437 
    while True:
23438 
      (fname, ftype, fid) = iprot.readFieldBegin()
23439 
      if ftype == TType.STOP:
23440 
        break
23441 
      if fid == 1:
23442 
        if ftype == TType.I64:
23443 
          self.orderId = iprot.readI64();
23444 
        else:
23445 
          iprot.skip(ftype)
23446 
      else:
23447 
        iprot.skip(ftype)
23448 
      iprot.readFieldEnd()
23449 
    iprot.readStructEnd()
23450 
 
23451 
  def write(self, oprot):
23452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23454 
      return
23455 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23456 
    if self.orderId is not None:
23457 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23458 
      oprot.writeI64(self.orderId)
23459 
      oprot.writeFieldEnd()
23460 
    oprot.writeFieldStop()
23461 
    oprot.writeStructEnd()
23462 
 
23463 
  def validate(self):
23464 
    return
23465 
 
23466 
 
23467 
  def __repr__(self):
23468 
    L = ['%s=%r' % (key, value)
23469 
      for key, value in self.__dict__.iteritems()]
23470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23471 
 
23472 
  def __eq__(self, other):
23473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23474 
 
23475 
  def __ne__(self, other):
23476 
    return not (self == other)
23477 
 
23478 
class updateOrderOnlyAsPaidToVendor_result:
23479 
  """
23480 
  Attributes:
23481 
   - ex
23482 
  """
23483 
 
23484 
  thrift_spec = (
23485 
    None, # 0
23486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23487 
  )
23488 
 
23489 
  def __init__(self, ex=None,):
23490 
    self.ex = ex
23491 
 
23492 
  def read(self, iprot):
23493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23495 
      return
23496 
    iprot.readStructBegin()
23497 
    while True:
23498 
      (fname, ftype, fid) = iprot.readFieldBegin()
23499 
      if ftype == TType.STOP:
23500 
        break
23501 
      if fid == 1:
23502 
        if ftype == TType.STRUCT:
23503 
          self.ex = TransactionServiceException()
23504 
          self.ex.read(iprot)
23505 
        else:
23506 
          iprot.skip(ftype)
23507 
      else:
23508 
        iprot.skip(ftype)
23509 
      iprot.readFieldEnd()
23510 
    iprot.readStructEnd()
23511 
 
23512 
  def write(self, oprot):
23513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23515 
      return
23516 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23517 
    if self.ex is not None:
23518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23519 
      self.ex.write(oprot)
23520 
      oprot.writeFieldEnd()
23521 
    oprot.writeFieldStop()
23522 
    oprot.writeStructEnd()
23523 
 
23524 
  def validate(self):
23525 
    return
23526 
 
23527 
 
23528 
  def __repr__(self):
23529 
    L = ['%s=%r' % (key, value)
23530 
      for key, value in self.__dict__.iteritems()]
23531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23532 
 
23533 
  def __eq__(self, other):
23534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23535 
 
23536 
  def __ne__(self, other):
23537 
    return not (self == other)
23538 
 
5208 varun.gupt 23539 
class getRefundedOrdersMarkedPaid_args:
23540 
 
23541 
  thrift_spec = (
23542 
  )
23543 
 
23544 
  def read(self, iprot):
23545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23547 
      return
23548 
    iprot.readStructBegin()
23549 
    while True:
23550 
      (fname, ftype, fid) = iprot.readFieldBegin()
23551 
      if ftype == TType.STOP:
23552 
        break
23553 
      else:
23554 
        iprot.skip(ftype)
23555 
      iprot.readFieldEnd()
23556 
    iprot.readStructEnd()
23557 
 
23558 
  def write(self, oprot):
23559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23561 
      return
23562 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23563 
    oprot.writeFieldStop()
23564 
    oprot.writeStructEnd()
23565 
 
23566 
  def validate(self):
23567 
    return
23568 
 
23569 
 
23570 
  def __repr__(self):
23571 
    L = ['%s=%r' % (key, value)
23572 
      for key, value in self.__dict__.iteritems()]
23573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23574 
 
23575 
  def __eq__(self, other):
23576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23577 
 
23578 
  def __ne__(self, other):
23579 
    return not (self == other)
23580 
 
23581 
class getRefundedOrdersMarkedPaid_result:
23582 
  """
23583 
  Attributes:
23584 
   - success
23585 
   - ex
23586 
  """
23587 
 
23588 
  thrift_spec = (
23589 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23591 
  )
23592 
 
23593 
  def __init__(self, success=None, ex=None,):
23594 
    self.success = success
23595 
    self.ex = ex
23596 
 
23597 
  def read(self, iprot):
23598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23600 
      return
23601 
    iprot.readStructBegin()
23602 
    while True:
23603 
      (fname, ftype, fid) = iprot.readFieldBegin()
23604 
      if ftype == TType.STOP:
23605 
        break
23606 
      if fid == 0:
23607 
        if ftype == TType.LIST:
23608 
          self.success = []
5481 phani.kuma 23609 
          (_etype553, _size550) = iprot.readListBegin()
23610 
          for _i554 in xrange(_size550):
23611 
            _elem555 = Order()
23612 
            _elem555.read(iprot)
23613 
            self.success.append(_elem555)
5208 varun.gupt 23614 
          iprot.readListEnd()
23615 
        else:
23616 
          iprot.skip(ftype)
23617 
      elif fid == 1:
23618 
        if ftype == TType.STRUCT:
23619 
          self.ex = TransactionServiceException()
23620 
          self.ex.read(iprot)
23621 
        else:
23622 
          iprot.skip(ftype)
23623 
      else:
23624 
        iprot.skip(ftype)
23625 
      iprot.readFieldEnd()
23626 
    iprot.readStructEnd()
23627 
 
23628 
  def write(self, oprot):
23629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23631 
      return
23632 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23633 
    if self.success is not None:
23634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23636 
      for iter556 in self.success:
23637 
        iter556.write(oprot)
5208 varun.gupt 23638 
      oprot.writeListEnd()
23639 
      oprot.writeFieldEnd()
23640 
    if self.ex is not None:
23641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23642 
      self.ex.write(oprot)
23643 
      oprot.writeFieldEnd()
23644 
    oprot.writeFieldStop()
23645 
    oprot.writeStructEnd()
23646 
 
23647 
  def validate(self):
23648 
    return
23649 
 
23650 
 
23651 
  def __repr__(self):
23652 
    L = ['%s=%r' % (key, value)
23653 
      for key, value in self.__dict__.iteritems()]
23654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23655 
 
23656 
  def __eq__(self, other):
23657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23658 
 
23659 
  def __ne__(self, other):
23660 
    return not (self == other)
5447 anupam.sin 23661 
 
23662 
class getAllVerificationAgents_args:
23663 
  """
23664 
  Attributes:
23665 
   - minOrderId
23666 
   - maxOrderId
23667 
  """
23668 
 
23669 
  thrift_spec = (
23670 
    None, # 0
23671 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
23672 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
23673 
  )
23674 
 
23675 
  def __init__(self, minOrderId=None, maxOrderId=None,):
23676 
    self.minOrderId = minOrderId
23677 
    self.maxOrderId = maxOrderId
23678 
 
23679 
  def read(self, iprot):
23680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23682 
      return
23683 
    iprot.readStructBegin()
23684 
    while True:
23685 
      (fname, ftype, fid) = iprot.readFieldBegin()
23686 
      if ftype == TType.STOP:
23687 
        break
23688 
      if fid == 1:
23689 
        if ftype == TType.I64:
23690 
          self.minOrderId = iprot.readI64();
23691 
        else:
23692 
          iprot.skip(ftype)
23693 
      elif fid == 2:
23694 
        if ftype == TType.I64:
23695 
          self.maxOrderId = iprot.readI64();
23696 
        else:
23697 
          iprot.skip(ftype)
23698 
      else:
23699 
        iprot.skip(ftype)
23700 
      iprot.readFieldEnd()
23701 
    iprot.readStructEnd()
23702 
 
23703 
  def write(self, oprot):
23704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23706 
      return
23707 
    oprot.writeStructBegin('getAllVerificationAgents_args')
23708 
    if self.minOrderId is not None:
23709 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
23710 
      oprot.writeI64(self.minOrderId)
23711 
      oprot.writeFieldEnd()
23712 
    if self.maxOrderId is not None:
23713 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
23714 
      oprot.writeI64(self.maxOrderId)
23715 
      oprot.writeFieldEnd()
23716 
    oprot.writeFieldStop()
23717 
    oprot.writeStructEnd()
23718 
 
23719 
  def validate(self):
23720 
    return
23721 
 
23722 
 
23723 
  def __repr__(self):
23724 
    L = ['%s=%r' % (key, value)
23725 
      for key, value in self.__dict__.iteritems()]
23726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23727 
 
23728 
  def __eq__(self, other):
23729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23730 
 
23731 
  def __ne__(self, other):
23732 
    return not (self == other)
23733 
 
23734 
class getAllVerificationAgents_result:
23735 
  """
23736 
  Attributes:
23737 
   - success
23738 
  """
23739 
 
23740 
  thrift_spec = (
23741 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
23742 
  )
23743 
 
23744 
  def __init__(self, success=None,):
23745 
    self.success = success
23746 
 
23747 
  def read(self, iprot):
23748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23750 
      return
23751 
    iprot.readStructBegin()
23752 
    while True:
23753 
      (fname, ftype, fid) = iprot.readFieldBegin()
23754 
      if ftype == TType.STOP:
23755 
        break
23756 
      if fid == 0:
23757 
        if ftype == TType.LIST:
23758 
          self.success = []
5481 phani.kuma 23759 
          (_etype560, _size557) = iprot.readListBegin()
23760 
          for _i561 in xrange(_size557):
23761 
            _elem562 = CODVerificationAgent()
23762 
            _elem562.read(iprot)
23763 
            self.success.append(_elem562)
5447 anupam.sin 23764 
          iprot.readListEnd()
23765 
        else:
23766 
          iprot.skip(ftype)
23767 
      else:
23768 
        iprot.skip(ftype)
23769 
      iprot.readFieldEnd()
23770 
    iprot.readStructEnd()
23771 
 
23772 
  def write(self, oprot):
23773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23775 
      return
23776 
    oprot.writeStructBegin('getAllVerificationAgents_result')
23777 
    if self.success is not None:
23778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23780 
      for iter563 in self.success:
23781 
        iter563.write(oprot)
5447 anupam.sin 23782 
      oprot.writeListEnd()
23783 
      oprot.writeFieldEnd()
23784 
    oprot.writeFieldStop()
23785 
    oprot.writeStructEnd()
23786 
 
23787 
  def validate(self):
23788 
    return
23789 
 
23790 
 
23791 
  def __repr__(self):
23792 
    L = ['%s=%r' % (key, value)
23793 
      for key, value in self.__dict__.iteritems()]
23794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23795 
 
23796 
  def __eq__(self, other):
23797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23798 
 
23799 
  def __ne__(self, other):
23800 
    return not (self == other)
5527 anupam.sin 23801 
 
23802 
class getAllAttributesForOrderId_args:
23803 
  """
23804 
  Attributes:
23805 
   - orderId
23806 
  """
23807 
 
23808 
  thrift_spec = (
23809 
    None, # 0
23810 
    (1, TType.I64, 'orderId', None, None, ), # 1
23811 
  )
23812 
 
23813 
  def __init__(self, orderId=None,):
23814 
    self.orderId = orderId
23815 
 
23816 
  def read(self, iprot):
23817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23819 
      return
23820 
    iprot.readStructBegin()
23821 
    while True:
23822 
      (fname, ftype, fid) = iprot.readFieldBegin()
23823 
      if ftype == TType.STOP:
23824 
        break
23825 
      if fid == 1:
23826 
        if ftype == TType.I64:
23827 
          self.orderId = iprot.readI64();
23828 
        else:
23829 
          iprot.skip(ftype)
23830 
      else:
23831 
        iprot.skip(ftype)
23832 
      iprot.readFieldEnd()
23833 
    iprot.readStructEnd()
23834 
 
23835 
  def write(self, oprot):
23836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23838 
      return
23839 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
23840 
    if self.orderId is not None:
23841 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23842 
      oprot.writeI64(self.orderId)
23843 
      oprot.writeFieldEnd()
23844 
    oprot.writeFieldStop()
23845 
    oprot.writeStructEnd()
23846 
 
23847 
  def validate(self):
23848 
    return
23849 
 
23850 
 
23851 
  def __repr__(self):
23852 
    L = ['%s=%r' % (key, value)
23853 
      for key, value in self.__dict__.iteritems()]
23854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23855 
 
23856 
  def __eq__(self, other):
23857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23858 
 
23859 
  def __ne__(self, other):
23860 
    return not (self == other)
23861 
 
23862 
class getAllAttributesForOrderId_result:
23863 
  """
23864 
  Attributes:
23865 
   - success
23866 
  """
23867 
 
23868 
  thrift_spec = (
23869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
23870 
  )
23871 
 
23872 
  def __init__(self, success=None,):
23873 
    self.success = success
23874 
 
23875 
  def read(self, iprot):
23876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23878 
      return
23879 
    iprot.readStructBegin()
23880 
    while True:
23881 
      (fname, ftype, fid) = iprot.readFieldBegin()
23882 
      if ftype == TType.STOP:
23883 
        break
23884 
      if fid == 0:
23885 
        if ftype == TType.LIST:
23886 
          self.success = []
5553 rajveer 23887 
          (_etype567, _size564) = iprot.readListBegin()
23888 
          for _i568 in xrange(_size564):
23889 
            _elem569 = Attribute()
23890 
            _elem569.read(iprot)
23891 
            self.success.append(_elem569)
5527 anupam.sin 23892 
          iprot.readListEnd()
23893 
        else:
23894 
          iprot.skip(ftype)
23895 
      else:
23896 
        iprot.skip(ftype)
23897 
      iprot.readFieldEnd()
23898 
    iprot.readStructEnd()
23899 
 
23900 
  def write(self, oprot):
23901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23903 
      return
23904 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
23905 
    if self.success is not None:
23906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23907 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5553 rajveer 23908 
      for iter570 in self.success:
23909 
        iter570.write(oprot)
5527 anupam.sin 23910 
      oprot.writeListEnd()
23911 
      oprot.writeFieldEnd()
23912 
    oprot.writeFieldStop()
23913 
    oprot.writeStructEnd()
23914 
 
23915 
  def validate(self):
23916 
    return
23917 
 
23918 
 
23919 
  def __repr__(self):
23920 
    L = ['%s=%r' % (key, value)
23921 
      for key, value in self.__dict__.iteritems()]
23922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23923 
 
23924 
  def __eq__(self, other):
23925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23926 
 
23927 
  def __ne__(self, other):
23928 
    return not (self == other)
23929 
 
23930 
class setOrderAttributeForTransaction_args:
23931 
  """
23932 
  Attributes:
23933 
   - transactionId
23934 
   - attribute
23935 
  """
23936 
 
23937 
  thrift_spec = None
23938 
  def __init__(self, transactionId=None, attribute=None,):
23939 
    self.transactionId = transactionId
23940 
    self.attribute = attribute
23941 
 
23942 
  def read(self, iprot):
23943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23945 
      return
23946 
    iprot.readStructBegin()
23947 
    while True:
23948 
      (fname, ftype, fid) = iprot.readFieldBegin()
23949 
      if ftype == TType.STOP:
23950 
        break
23951 
      if fid == 1:
23952 
        if ftype == TType.I64:
23953 
          self.transactionId = iprot.readI64();
23954 
        else:
23955 
          iprot.skip(ftype)
23956 
      elif fid == -1:
23957 
        if ftype == TType.STRUCT:
23958 
          self.attribute = Attribute()
23959 
          self.attribute.read(iprot)
23960 
        else:
23961 
          iprot.skip(ftype)
23962 
      else:
23963 
        iprot.skip(ftype)
23964 
      iprot.readFieldEnd()
23965 
    iprot.readStructEnd()
23966 
 
23967 
  def write(self, oprot):
23968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23970 
      return
23971 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
23972 
    if self.attribute is not None:
23973 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
23974 
      self.attribute.write(oprot)
23975 
      oprot.writeFieldEnd()
23976 
    if self.transactionId is not None:
23977 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
23978 
      oprot.writeI64(self.transactionId)
23979 
      oprot.writeFieldEnd()
23980 
    oprot.writeFieldStop()
23981 
    oprot.writeStructEnd()
23982 
 
23983 
  def validate(self):
23984 
    return
23985 
 
23986 
 
23987 
  def __repr__(self):
23988 
    L = ['%s=%r' % (key, value)
23989 
      for key, value in self.__dict__.iteritems()]
23990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23991 
 
23992 
  def __eq__(self, other):
23993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23994 
 
23995 
  def __ne__(self, other):
23996 
    return not (self == other)
23997 
 
23998 
class setOrderAttributeForTransaction_result:
23999 
 
24000 
  thrift_spec = (
24001 
  )
24002 
 
24003 
  def read(self, iprot):
24004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24006 
      return
24007 
    iprot.readStructBegin()
24008 
    while True:
24009 
      (fname, ftype, fid) = iprot.readFieldBegin()
24010 
      if ftype == TType.STOP:
24011 
        break
24012 
      else:
24013 
        iprot.skip(ftype)
24014 
      iprot.readFieldEnd()
24015 
    iprot.readStructEnd()
24016 
 
24017 
  def write(self, oprot):
24018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24020 
      return
24021 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24022 
    oprot.writeFieldStop()
24023 
    oprot.writeStructEnd()
24024 
 
24025 
  def validate(self):
24026 
    return
24027 
 
24028 
 
24029 
  def __repr__(self):
24030 
    L = ['%s=%r' % (key, value)
24031 
      for key, value in self.__dict__.iteritems()]
24032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24033 
 
24034 
  def __eq__(self, other):
24035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24036 
 
24037 
  def __ne__(self, other):
24038 
    return not (self == other)
5553 rajveer 24039 
 
24040 
class getReceivePendingOrders_args:
24041 
  """
24042 
  Attributes:
24043 
   - storeId
24044 
  """
24045 
 
24046 
  thrift_spec = (
24047 
    None, # 0
24048 
    (1, TType.I64, 'storeId', None, None, ), # 1
24049 
  )
24050 
 
24051 
  def __init__(self, storeId=None,):
24052 
    self.storeId = storeId
24053 
 
24054 
  def read(self, iprot):
24055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24057 
      return
24058 
    iprot.readStructBegin()
24059 
    while True:
24060 
      (fname, ftype, fid) = iprot.readFieldBegin()
24061 
      if ftype == TType.STOP:
24062 
        break
24063 
      if fid == 1:
24064 
        if ftype == TType.I64:
24065 
          self.storeId = iprot.readI64();
24066 
        else:
24067 
          iprot.skip(ftype)
24068 
      else:
24069 
        iprot.skip(ftype)
24070 
      iprot.readFieldEnd()
24071 
    iprot.readStructEnd()
24072 
 
24073 
  def write(self, oprot):
24074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24076 
      return
24077 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24078 
    if self.storeId is not None:
24079 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24080 
      oprot.writeI64(self.storeId)
24081 
      oprot.writeFieldEnd()
24082 
    oprot.writeFieldStop()
24083 
    oprot.writeStructEnd()
24084 
 
24085 
  def validate(self):
24086 
    return
24087 
 
24088 
 
24089 
  def __repr__(self):
24090 
    L = ['%s=%r' % (key, value)
24091 
      for key, value in self.__dict__.iteritems()]
24092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24093 
 
24094 
  def __eq__(self, other):
24095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24096 
 
24097 
  def __ne__(self, other):
24098 
    return not (self == other)
24099 
 
24100 
class getReceivePendingOrders_result:
24101 
  """
24102 
  Attributes:
24103 
   - success
24104 
  """
24105 
 
24106 
  thrift_spec = (
24107 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24108 
  )
24109 
 
24110 
  def __init__(self, success=None,):
24111 
    self.success = success
24112 
 
24113 
  def read(self, iprot):
24114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24116 
      return
24117 
    iprot.readStructBegin()
24118 
    while True:
24119 
      (fname, ftype, fid) = iprot.readFieldBegin()
24120 
      if ftype == TType.STOP:
24121 
        break
24122 
      if fid == 0:
24123 
        if ftype == TType.LIST:
24124 
          self.success = []
24125 
          (_etype574, _size571) = iprot.readListBegin()
24126 
          for _i575 in xrange(_size571):
24127 
            _elem576 = Order()
24128 
            _elem576.read(iprot)
24129 
            self.success.append(_elem576)
24130 
          iprot.readListEnd()
24131 
        else:
24132 
          iprot.skip(ftype)
24133 
      else:
24134 
        iprot.skip(ftype)
24135 
      iprot.readFieldEnd()
24136 
    iprot.readStructEnd()
24137 
 
24138 
  def write(self, oprot):
24139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24141 
      return
24142 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24143 
    if self.success is not None:
24144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24145 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24146 
      for iter577 in self.success:
24147 
        iter577.write(oprot)
24148 
      oprot.writeListEnd()
24149 
      oprot.writeFieldEnd()
24150 
    oprot.writeFieldStop()
24151 
    oprot.writeStructEnd()
24152 
 
24153 
  def validate(self):
24154 
    return
24155 
 
24156 
 
24157 
  def __repr__(self):
24158 
    L = ['%s=%r' % (key, value)
24159 
      for key, value in self.__dict__.iteritems()]
24160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24161 
 
24162 
  def __eq__(self, other):
24163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24164 
 
24165 
  def __ne__(self, other):
24166 
    return not (self == other)
24167 
 
24168 
class getReceivedAtStoreOrders_args:
24169 
  """
24170 
  Attributes:
24171 
   - storeId
24172 
  """
24173 
 
24174 
  thrift_spec = (
24175 
    None, # 0
24176 
    (1, TType.I64, 'storeId', None, None, ), # 1
24177 
  )
24178 
 
24179 
  def __init__(self, storeId=None,):
24180 
    self.storeId = storeId
24181 
 
24182 
  def read(self, iprot):
24183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24185 
      return
24186 
    iprot.readStructBegin()
24187 
    while True:
24188 
      (fname, ftype, fid) = iprot.readFieldBegin()
24189 
      if ftype == TType.STOP:
24190 
        break
24191 
      if fid == 1:
24192 
        if ftype == TType.I64:
24193 
          self.storeId = iprot.readI64();
24194 
        else:
24195 
          iprot.skip(ftype)
24196 
      else:
24197 
        iprot.skip(ftype)
24198 
      iprot.readFieldEnd()
24199 
    iprot.readStructEnd()
24200 
 
24201 
  def write(self, oprot):
24202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24204 
      return
24205 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24206 
    if self.storeId is not None:
24207 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24208 
      oprot.writeI64(self.storeId)
24209 
      oprot.writeFieldEnd()
24210 
    oprot.writeFieldStop()
24211 
    oprot.writeStructEnd()
24212 
 
24213 
  def validate(self):
24214 
    return
24215 
 
24216 
 
24217 
  def __repr__(self):
24218 
    L = ['%s=%r' % (key, value)
24219 
      for key, value in self.__dict__.iteritems()]
24220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24221 
 
24222 
  def __eq__(self, other):
24223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24224 
 
24225 
  def __ne__(self, other):
24226 
    return not (self == other)
24227 
 
24228 
class getReceivedAtStoreOrders_result:
24229 
  """
24230 
  Attributes:
24231 
   - success
24232 
  """
24233 
 
24234 
  thrift_spec = (
24235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24236 
  )
24237 
 
24238 
  def __init__(self, success=None,):
24239 
    self.success = success
24240 
 
24241 
  def read(self, iprot):
24242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24244 
      return
24245 
    iprot.readStructBegin()
24246 
    while True:
24247 
      (fname, ftype, fid) = iprot.readFieldBegin()
24248 
      if ftype == TType.STOP:
24249 
        break
24250 
      if fid == 0:
24251 
        if ftype == TType.LIST:
24252 
          self.success = []
24253 
          (_etype581, _size578) = iprot.readListBegin()
24254 
          for _i582 in xrange(_size578):
24255 
            _elem583 = Order()
24256 
            _elem583.read(iprot)
24257 
            self.success.append(_elem583)
24258 
          iprot.readListEnd()
24259 
        else:
24260 
          iprot.skip(ftype)
24261 
      else:
24262 
        iprot.skip(ftype)
24263 
      iprot.readFieldEnd()
24264 
    iprot.readStructEnd()
24265 
 
24266 
  def write(self, oprot):
24267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24269 
      return
24270 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24271 
    if self.success is not None:
24272 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24273 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24274 
      for iter584 in self.success:
24275 
        iter584.write(oprot)
24276 
      oprot.writeListEnd()
24277 
      oprot.writeFieldEnd()
24278 
    oprot.writeFieldStop()
24279 
    oprot.writeStructEnd()
24280 
 
24281 
  def validate(self):
24282 
    return
24283 
 
24284 
 
24285 
  def __repr__(self):
24286 
    L = ['%s=%r' % (key, value)
24287 
      for key, value in self.__dict__.iteritems()]
24288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24289 
 
24290 
  def __eq__(self, other):
24291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24292 
 
24293 
  def __ne__(self, other):
24294 
    return not (self == other)
5593 mandeep.dh 24295 
 
24296 
class acceptOrderForItem_args:
24297 
  """
24298 
  Attributes:
24299 
   - itemId
24300 
   - quantity
24301 
   - fulfilmentWarehouseId
24302 
   - billingWarehouseId
24303 
  """
24304 
 
24305 
  thrift_spec = (
24306 
    None, # 0
24307 
    (1, TType.I64, 'itemId', None, None, ), # 1
24308 
    (2, TType.I64, 'quantity', None, None, ), # 2
24309 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
24310 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
24311 
  )
24312 
 
24313 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
24314 
    self.itemId = itemId
24315 
    self.quantity = quantity
24316 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
24317 
    self.billingWarehouseId = billingWarehouseId
24318 
 
24319 
  def read(self, iprot):
24320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24322 
      return
24323 
    iprot.readStructBegin()
24324 
    while True:
24325 
      (fname, ftype, fid) = iprot.readFieldBegin()
24326 
      if ftype == TType.STOP:
24327 
        break
24328 
      if fid == 1:
24329 
        if ftype == TType.I64:
24330 
          self.itemId = iprot.readI64();
24331 
        else:
24332 
          iprot.skip(ftype)
24333 
      elif fid == 2:
24334 
        if ftype == TType.I64:
24335 
          self.quantity = iprot.readI64();
24336 
        else:
24337 
          iprot.skip(ftype)
24338 
      elif fid == 3:
24339 
        if ftype == TType.I64:
24340 
          self.fulfilmentWarehouseId = iprot.readI64();
24341 
        else:
24342 
          iprot.skip(ftype)
24343 
      elif fid == 4:
24344 
        if ftype == TType.I64:
24345 
          self.billingWarehouseId = iprot.readI64();
24346 
        else:
24347 
          iprot.skip(ftype)
24348 
      else:
24349 
        iprot.skip(ftype)
24350 
      iprot.readFieldEnd()
24351 
    iprot.readStructEnd()
24352 
 
24353 
  def write(self, oprot):
24354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24356 
      return
24357 
    oprot.writeStructBegin('acceptOrderForItem_args')
24358 
    if self.itemId is not None:
24359 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24360 
      oprot.writeI64(self.itemId)
24361 
      oprot.writeFieldEnd()
24362 
    if self.quantity is not None:
24363 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
24364 
      oprot.writeI64(self.quantity)
24365 
      oprot.writeFieldEnd()
24366 
    if self.fulfilmentWarehouseId is not None:
24367 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
24368 
      oprot.writeI64(self.fulfilmentWarehouseId)
24369 
      oprot.writeFieldEnd()
24370 
    if self.billingWarehouseId is not None:
24371 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
24372 
      oprot.writeI64(self.billingWarehouseId)
24373 
      oprot.writeFieldEnd()
24374 
    oprot.writeFieldStop()
24375 
    oprot.writeStructEnd()
24376 
 
24377 
  def validate(self):
24378 
    return
24379 
 
24380 
 
24381 
  def __repr__(self):
24382 
    L = ['%s=%r' % (key, value)
24383 
      for key, value in self.__dict__.iteritems()]
24384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24385 
 
24386 
  def __eq__(self, other):
24387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24388 
 
24389 
  def __ne__(self, other):
24390 
    return not (self == other)
24391 
 
24392 
class acceptOrderForItem_result:
24393 
 
24394 
  thrift_spec = (
24395 
  )
24396 
 
24397 
  def read(self, iprot):
24398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24400 
      return
24401 
    iprot.readStructBegin()
24402 
    while True:
24403 
      (fname, ftype, fid) = iprot.readFieldBegin()
24404 
      if ftype == TType.STOP:
24405 
        break
24406 
      else:
24407 
        iprot.skip(ftype)
24408 
      iprot.readFieldEnd()
24409 
    iprot.readStructEnd()
24410 
 
24411 
  def write(self, oprot):
24412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24414 
      return
24415 
    oprot.writeStructBegin('acceptOrderForItem_result')
24416 
    oprot.writeFieldStop()
24417 
    oprot.writeStructEnd()
24418 
 
24419 
  def validate(self):
24420 
    return
24421 
 
24422 
 
24423 
  def __repr__(self):
24424 
    L = ['%s=%r' % (key, value)
24425 
      for key, value in self.__dict__.iteritems()]
24426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24427 
 
24428 
  def __eq__(self, other):
24429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24430 
 
24431 
  def __ne__(self, other):
24432 
    return not (self == other)