Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4763 rajveer 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
4763 rajveer 336 
     - authorize
3064 chandransh 337 
    """
338 
    pass
339 
 
4763 rajveer 340 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 341 
    """
342 
    Add the invoice number to the order.
343 
 
344 
    Parameters:
345 
     - orderId
346 
     - invoiceNumber
4763 rajveer 347 
     - color
4579 rajveer 348 
    """
349 
    pass
350 
 
4910 phani.kuma 351 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 355 
 
356 
    Parameters:
357 
     - warehouseId
358 
     - providerId
359 
     - cod
4910 phani.kuma 360 
     - orderIds
4410 rajveer 361 
    """
362 
    pass
363 
 
4910 phani.kuma 364 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 365 
    """
4910 phani.kuma 366 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
367 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 368 
 
3064 chandransh 369 
    Parameters:
759 chandransh 370 
     - providerId
4910 phani.kuma 371 
     - pickupDetails
759 chandransh 372 
    """
373 
    pass
374 
 
4910 phani.kuma 375 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 376 
    """
377 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
    """
382 
    pass
383 
 
1132 chandransh 384 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
385 
    """
386 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
387 
    the name of the receiver.
388 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 389 
 
1132 chandransh 390 
    Parameters:
391 
     - providerId
392 
     - deliveredOrders
393 
    """
394 
    pass
395 
 
4910 phani.kuma 396 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 397 
    """
4910 phani.kuma 398 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 399 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 400 
 
1135 chandransh 401 
    Parameters:
402 
     - providerId
403 
     - returnedOrders
404 
    """
405 
    pass
406 
 
4910 phani.kuma 407 
  def getRTOrders(self, providerId):
408 
    """
409 
    Returns a list of orders that were returned by courier.
410 
 
411 
    Parameters:
412 
     - providerId
413 
    """
414 
    pass
415 
 
1246 chandransh 416 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
417 
    """
418 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 419 
 
1246 chandransh 420 
    Parameters:
421 
     - providerId
422 
     - undeliveredOrders
423 
    """
424 
    pass
425 
 
4910 phani.kuma 426 
  def getNonDeliveredOrdersbyCourier(self, providerId):
427 
    """
428 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
429 
 
430 
    Parameters:
431 
     - providerId
432 
    """
433 
    pass
434 
 
435 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
436 
    """
437 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
438 
 
439 
    Parameters:
440 
     - providerId
441 
     - local_connected_orders
442 
    """
443 
    pass
444 
 
445 
  def getOrdersNotLocalConnected(self, providerId):
446 
    """
447 
    Returns a list of orders that were picked up or shipped but pending local connection.
448 
 
449 
    Parameters:
450 
     - providerId
451 
    """
452 
    pass
453 
 
454 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
455 
    """
456 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
457 
 
458 
    Parameters:
459 
     - providerId
460 
     - destination_city_reached_orders
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - first_atdl_orders
471 
    """
472 
    pass
473 
 
1408 ankur.sing 474 
  def getUndeliveredOrders(self, providerId, warehouseId):
475 
    """
476 
    Returns the list of orders whose delivery time has passed but have not been
477 
    delivered yet for the given provider and warehouse. To get a complete list of
478 
    undelivered orders, pass them as -1.
479 
    Returns an empty list if no such orders exist.
3431 rajveer 480 
 
1408 ankur.sing 481 
    Parameters:
482 
     - providerId
483 
     - warehouseId
484 
    """
485 
    pass
486 
 
4783 phani.kuma 487 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
488 
    """
489 
    Returns the list of orders whose expected delivery date has passed but have not been
490 
    delivered yet.
491 
    Returns an empty list if no such orders exist.
492 
    """
493 
    pass
494 
 
2536 chandransh 495 
  def toggleDOAFlag(self, orderId):
496 
    """
497 
    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.
498 
    Returns the final flag status.
499 
    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 500 
 
2536 chandransh 501 
    Parameters:
502 
     - orderId
503 
    """
504 
    pass
1886 ankur.sing 505 
 
4712 rajveer 506 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
507 
    """
508 
    Parameters:
509 
     - orderId
510 
     - deliveryTimestamp
511 
     - receiver
512 
    """
513 
    pass
514 
 
4454 rajveer 515 
  def markOrderDoaRequestReceived(self, orderId):
516 
    """
517 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
518 
 
519 
    Parameters:
520 
     - orderId
521 
    """
522 
    pass
523 
 
524 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
525 
    """
526 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
527 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
528 
 
529 
    Parameters:
530 
     - orderId
531 
     - isAuthorized
532 
    """
533 
    pass
534 
 
4488 rajveer 535 
  def markOrderReturnRequestReceived(self, orderId):
536 
    """
537 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
538 
 
539 
    Parameters:
540 
     - orderId
541 
    """
542 
    pass
543 
 
544 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
545 
    """
546 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
547 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
548 
 
549 
    Parameters:
550 
     - orderId
551 
     - isAuthorized
552 
    """
553 
    pass
554 
 
4579 rajveer 555 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 556 
    """
557 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 558 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
559 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 560 
    For any other status, it returns false.
561 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 562 
 
2536 chandransh 563 
    Parameters:
564 
     - orderId
4579 rajveer 565 
     - providerId
2536 chandransh 566 
    """
567 
    pass
568 
 
4602 rajveer 569 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 570 
    """
4452 rajveer 571 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 572 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
573 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
574 
    	3. Returns true
2591 chandransh 575 
    If the order is in any other status, it returns false.
2536 chandransh 576 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 577 
 
2536 chandransh 578 
    Parameters:
579 
     - orderId
580 
     - pickupNumber
4602 rajveer 581 
     - providerId
2536 chandransh 582 
    """
583 
    pass
584 
 
2764 chandransh 585 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
586 
    """
587 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 588 
 
2764 chandransh 589 
    Parameters:
590 
     - providerId
591 
     - pickupDetails
592 
    """
593 
    pass
594 
 
4910 phani.kuma 595 
  def getDoasNotPickedUp(self, providerId):
596 
    """
597 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
598 
 
599 
    Parameters:
600 
     - providerId
601 
    """
602 
    pass
603 
 
4741 phani.kuma 604 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
605 
    """
606 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
607 
 
608 
    Parameters:
609 
     - providerId
610 
     - pickupDetails
611 
    """
612 
    pass
613 
 
4910 phani.kuma 614 
  def getReturnOrdersNotPickedUp(self, providerId):
615 
    """
616 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
617 
 
618 
    Parameters:
619 
     - providerId
620 
    """
621 
    pass
622 
 
4479 rajveer 623 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 624 
    """
4452 rajveer 625 
    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 626 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 627 
    If the order is in any other state, it returns false.
628 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 629 
 
2591 chandransh 630 
    Parameters:
631 
     - orderId
4479 rajveer 632 
     - receiveCondition
2591 chandransh 633 
    """
634 
    pass
2536 chandransh 635 
 
2591 chandransh 636 
  def validateDoa(self, orderId, isValid):
637 
    """
4452 rajveer 638 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 639 
    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 640 
    If the order is in any other state, it returns false.
641 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 642 
 
2591 chandransh 643 
    Parameters:
644 
     - orderId
645 
     - isValid
646 
    """
647 
    pass
648 
 
4495 rajveer 649 
  def validateReturnProduct(self, orderId, isUsable):
650 
    """
651 
    Parameters:
652 
     - orderId
653 
     - isUsable
654 
    """
655 
    pass
656 
 
2616 chandransh 657 
  def reshipOrder(self, orderId):
658 
    """
4484 rajveer 659 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 660 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 661 
    	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 662 
 
663 
    If the order is in DOA_CERT_VALID state, it does the following:
664 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
665 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 666 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 667 
 
2616 chandransh 668 
    Returns the id of the newly created order.
3431 rajveer 669 
 
2616 chandransh 670 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 671 
 
2616 chandransh 672 
    Parameters:
673 
     - orderId
674 
    """
675 
    pass
2591 chandransh 676 
 
3226 chandransh 677 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 678 
    """
4484 rajveer 679 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 680 
    	1. Creates a refund request for batch processing.
681 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 682 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 683 
 
2616 chandransh 684 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
685 
    	1. Creates a refund request for batch processing.
3226 chandransh 686 
    	2. Cancels the reservation of the item in the warehouse.
687 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 688 
 
3226 chandransh 689 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
690 
    	1. Cancels the reservation of the item in the warehouse.
691 
    	2. Marks the current order as CANCELED.
692 
 
693 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
694 
 
2616 chandransh 695 
    Returns True if it is successful, False otherwise.
3431 rajveer 696 
 
2616 chandransh 697 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 698 
 
2616 chandransh 699 
    Parameters:
700 
     - orderId
3226 chandransh 701 
     - refundedBy
702 
     - reason
2616 chandransh 703 
    """
704 
    pass
705 
 
2690 chandransh 706 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
707 
    """
708 
    Get all return orders created between the from and to dates for the given warehouse.
709 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 710 
 
2690 chandransh 711 
    Parameters:
712 
     - warehouseId
713 
     - fromDate
714 
     - toDate
715 
    """
716 
    pass
2616 chandransh 717 
 
2700 chandransh 718 
  def getReturnOrder(self, id):
719 
    """
720 
    Returns the ReturnOrder corresponding to the given id.
721 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 722 
 
2700 chandransh 723 
    Parameters:
724 
     - id
725 
    """
726 
    pass
727 
 
2690 chandransh 728 
  def processReturn(self, returnOrderId):
729 
    """
730 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 731 
 
2690 chandransh 732 
    Parameters:
733 
     - returnOrderId
734 
    """
735 
    pass
736 
 
3451 chandransh 737 
  def updateWeight(self, orderId, weight):
738 
    """
739 
    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 740 
 
3451 chandransh 741 
    Parameters:
742 
     - orderId
743 
     - weight
744 
    """
745 
    pass
746 
 
3469 chandransh 747 
  def changeItem(self, orderId, itemId):
748 
    """
749 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
750 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 751 
 
3469 chandransh 752 
    Parameters:
753 
     - orderId
754 
     - itemId
755 
    """
756 
    pass
757 
 
758 
  def shiftToWarehouse(self, orderId, warehouseId):
759 
    """
760 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
761 
 
762 
    Parameters:
763 
     - orderId
764 
     - warehouseId
765 
    """
766 
    pass
767 
 
4647 rajveer 768 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 769 
    """
770 
    Adds the given delay reason to the given order.
3986 chandransh 771 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 772 
    Raises an exception if no order with the given id can be found.
3469 chandransh 773 
 
3553 chandransh 774 
    Parameters:
775 
     - orderId
776 
     - delayReason
3986 chandransh 777 
     - furtherDelay
4647 rajveer 778 
     - delayReasonText
3553 chandransh 779 
    """
780 
    pass
781 
 
3956 chandransh 782 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
783 
    """
784 
    Marks the COD orders with given AWB nos. as having been processed.
785 
    Updates the captured amount for the corresponding payment.
3553 chandransh 786 
 
3956 chandransh 787 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
788 
    1. There is no order corresponding to an AWB number.
789 
    2. The captured amount for a payment exceeds the total payment.
790 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
791 
 
792 
    Parameters:
793 
     - collectedAmountMap
794 
     - xferBy
795 
     - xferTxnId
796 
     - xferDate
797 
    """
798 
    pass
799 
 
4008 mandeep.dh 800 
  def getTransactionsRequiringExtraProcessing(self, category):
801 
    """
4065 mandeep.dh 802 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 803 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 804 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 805 
 
4008 mandeep.dh 806 
    Parameters:
807 
     - category
808 
    """
809 
    pass
810 
 
811 
  def markTransactionAsProcessed(self, transactionId, category):
812 
    """
813 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 814 
    It essentially deletes the transaction id record for a particular
815 
    processing type category (if present) from DB.
816 
    This is currently used by CRM application.
4008 mandeep.dh 817 
 
818 
    Parameters:
819 
     - transactionId
820 
     - category
821 
    """
822 
    pass
823 
 
4018 chandransh 824 
  def getItemWiseRiskyOrdersCount(self, ):
825 
    """
826 
    Returns a map containing the number of risky orders keyed by item id. A risky order
827 
    is defined as one whose shipping date is about to expire.
828 
    """
829 
    pass
4008 mandeep.dh 830 
 
4295 varun.gupt 831 
  def getOrdersForItemIds(self, itemIds):
832 
    """
833 
    Returns a list of all orders which have items with given id
834 
 
835 
    Parameters:
836 
     - itemIds
837 
    """
838 
    pass
839 
 
4247 rajveer 840 
  def markOrderCancellationRequestReceived(self, orderId):
841 
    """
842 
    Mark order as cancellation request received. If customer sends request of cancellation of
843 
    a particular order, this method will be called. It will just change status of the order
844 
    depending on its current status. It also records the previous status, so that we can move
845 
    back to that status if cancellation request is denied.
4018 chandransh 846 
 
4247 rajveer 847 
    Parameters:
848 
     - orderId
849 
    """
850 
    pass
851 
 
852 
  def markOrderCancellationRequestConfirmed(self, orderId):
853 
    """
854 
    If we decide to to cancel order, CRM will call this method to move the status of order to
855 
    cancellation request confirmed. After this OM will be able to cancel the order.
856 
 
857 
    Parameters:
858 
     - orderId
859 
    """
860 
    pass
861 
 
862 
  def markOrderCancellationRequestDenied(self, orderId):
863 
    """
864 
    If we decide to not to cancel order, we will move the order ro previous status.
865 
 
866 
    Parameters:
867 
     - orderId
868 
    """
869 
    pass
870 
 
4258 rajveer 871 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 872 
    """
4258 rajveer 873 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
874 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 875 
 
876 
    Parameters:
4258 rajveer 877 
     - transactionId
4247 rajveer 878 
    """
879 
    pass
880 
 
4259 anupam.sin 881 
  def refundTransaction(self, transactionId, refundedBy, reason):
882 
    """
883 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
884 
    need to be cancelled
4247 rajveer 885 
 
4259 anupam.sin 886 
    Parameters:
887 
     - transactionId
888 
     - refundedBy
889 
     - reason
890 
    """
891 
    pass
892 
 
4324 mandeep.dh 893 
  def updateShipmentAddress(self, orderId, addressId):
894 
    """
895 
    Updates shipment address of an order. Delivery and shipping date estimates
896 
    etc. are also updated here.
897 
 
898 
    Throws TransactionServiceException in case address change is not
899 
    possible due to certain reasons such as new pincode in address is
900 
    not serviceable etc.
901 
 
902 
    Parameters:
903 
     - orderId
904 
     - addressId
905 
    """
906 
    pass
907 
 
4285 rajveer 908 
  def acceptOrdersForItemId(self, itemId, inventory):
909 
    """
910 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
911 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 912 
 
4285 rajveer 913 
    Parameters:
914 
     - itemId
915 
     - inventory
916 
    """
917 
    pass
918 
 
4369 rajveer 919 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 920 
    """
921 
    Parameters:
922 
     - vendorId
923 
     - itemId
924 
     - quantity
925 
     - estimate
4369 rajveer 926 
     - isReminder
4303 rajveer 927 
    """
928 
    pass
4285 rajveer 929 
 
4369 rajveer 930 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 931 
    """
932 
    Parameters:
933 
     - vendorId
934 
     - itemId
935 
     - quantity
936 
     - estimate
4369 rajveer 937 
     - isReminder
4303 rajveer 938 
    """
939 
    pass
940 
 
4369 rajveer 941 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 942 
    """
943 
    Parameters:
944 
     - vendorId
945 
     - itemId
946 
     - quantity
947 
     - estimate
4369 rajveer 948 
     - isReminder
4303 rajveer 949 
    """
950 
    pass
951 
 
4369 rajveer 952 
  def markOrdersAsTimeout(self, vendorId):
953 
    """
954 
    Parameters:
955 
     - vendorId
956 
    """
957 
    pass
4303 rajveer 958 
 
4662 rajveer 959 
  def markOrderAsLostInTransit(self, orderId):
960 
    """
961 
    Mark order as LOST_IN_TRANSIT
962 
 
963 
    Parameters:
964 
     - orderId
965 
    """
966 
    pass
967 
 
4386 anupam.sin 968 
  def getOrderForAwb(self, awb):
969 
    """
970 
    Returns the order corresponding to an AWB number
4369 rajveer 971 
 
4386 anupam.sin 972 
    Parameters:
973 
     - awb
974 
    """
975 
    pass
976 
 
4910 phani.kuma 977 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 978 
    """
4910 phani.kuma 979 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 980 
 
4506 phani.kuma 981 
    Parameters:
982 
     - logistics_provider_id
4910 phani.kuma 983 
     - order_status_list
4506 phani.kuma 984 
    """
985 
    pass
986 
 
4600 varun.gupt 987 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
988 
    """
989 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 990 
 
4600 varun.gupt 991 
    Parameters:
992 
     - vendorId
993 
     - billingDateFrom
994 
     - billingDateTo
995 
    """
996 
    pass
997 
 
4607 rajveer 998 
  def getSlippedSippingDateOrders(self, ):
999 
    pass
1000 
 
4709 rajveer 1001 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1002 
    """
1003 
    Parameters:
1004 
     - cancelDateFrom
1005 
     - cancelDateTo
1006 
    """
1007 
    pass
1008 
 
4600 varun.gupt 1009 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1010 
    """
1011 
    Parameters:
1012 
     - mapAWBAndAmount
1013 
    """
1014 
    pass
1015 
 
4905 varun.gupt 1016 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1017 
    """
1018 
    Parameters:
1019 
     - settlementDate
1020 
     - paymentGatewayId
4905 varun.gupt 1021 
     - referenceId
4600 varun.gupt 1022 
     - serviceTax
1023 
     - otherCharges
1024 
     - netCollection
1025 
    """
1026 
    pass
1027 
 
1028 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1029 
    """
1030 
    Parameters:
1031 
     - settlementId
1032 
     - settlementDate
1033 
     - transactionDateFrom
1034 
     - transactionDateTo
1035 
     - amount
1036 
    """
1037 
    pass
1038 
 
1039 
  def getSettlementForPaymentId(self, paymentId):
1040 
    """
1041 
    Parameters:
1042 
     - paymentId
1043 
    """
1044 
    pass
1045 
 
1046 
  def getEBSSettlementSummaries(self, ):
1047 
    pass
1048 
 
1049 
  def markEBSSettlementUploaded(self, settlementId):
1050 
    """
1051 
    Parameters:
1052 
     - settlementId
1053 
    """
1054 
    pass
1055 
 
1056 
  def getEBSSettlementDate(self, settlementId):
1057 
    """
1058 
    Parameters:
1059 
     - settlementId
1060 
    """
1061 
    pass
1062 
 
4715 varun.gupt 1063 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1064 
    """
1065 
    Parameters:
1066 
     - settlementDateFrom
1067 
     - settlementDateTo
1068 
     - isRefund
1069 
    """
1070 
    pass
4600 varun.gupt 1071 
 
4715 varun.gupt 1072 
  def getReshippedOrderIds(self, orderIds):
1073 
    """
1074 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1075 
 
1076 
    Parameters:
1077 
     - orderIds
1078 
    """
1079 
    pass
1080 
 
4757 mandeep.dh 1081 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1082 
    """
1083 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1084 
    the quantities for which the PO is raised.
4715 varun.gupt 1085 
 
4757 mandeep.dh 1086 
    Parameters:
1087 
     - itemIdQuantityMap
1088 
     - purchaseOrderId
1089 
     - warehouseId
1090 
    """
1091 
    pass
1092 
 
4875 varun.gupt 1093 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1094 
    """
1095 
    Parameters:
1096 
     - vendorId
1097 
    """
1098 
    pass
4757 mandeep.dh 1099 
 
4875 varun.gupt 1100 
 
3376 rajveer 1101 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1102 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1103 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1104 
 
1105 
  def createTransaction(self, transaction):
1106 
    """
1107 
    Parameters:
1108 
     - transaction
1109 
    """
1110 
    self.send_createTransaction(transaction)
132 ashish 1111 
    return self.recv_createTransaction()
94 ashish 1112 
 
1113 
  def send_createTransaction(self, transaction):
1114 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1115 
    args = createTransaction_args()
1116 
    args.transaction = transaction
1117 
    args.write(self._oprot)
1118 
    self._oprot.writeMessageEnd()
1119 
    self._oprot.trans.flush()
1120 
 
1121 
  def recv_createTransaction(self, ):
1122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1123 
    if mtype == TMessageType.EXCEPTION:
1124 
      x = TApplicationException()
1125 
      x.read(self._iprot)
1126 
      self._iprot.readMessageEnd()
1127 
      raise x
1128 
    result = createTransaction_result()
1129 
    result.read(self._iprot)
1130 
    self._iprot.readMessageEnd()
3431 rajveer 1131 
    if result.success is not None:
132 ashish 1132 
      return result.success
3431 rajveer 1133 
    if result.ex is not None:
94 ashish 1134 
      raise result.ex
132 ashish 1135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1136 
 
1137 
  def getTransaction(self, id):
1138 
    """
1139 
    Parameters:
1140 
     - id
1141 
    """
1142 
    self.send_getTransaction(id)
1143 
    return self.recv_getTransaction()
1144 
 
1145 
  def send_getTransaction(self, id):
1146 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1147 
    args = getTransaction_args()
1148 
    args.id = id
1149 
    args.write(self._oprot)
1150 
    self._oprot.writeMessageEnd()
1151 
    self._oprot.trans.flush()
1152 
 
1153 
  def recv_getTransaction(self, ):
1154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1155 
    if mtype == TMessageType.EXCEPTION:
1156 
      x = TApplicationException()
1157 
      x.read(self._iprot)
1158 
      self._iprot.readMessageEnd()
1159 
      raise x
1160 
    result = getTransaction_result()
1161 
    result.read(self._iprot)
1162 
    self._iprot.readMessageEnd()
3431 rajveer 1163 
    if result.success is not None:
94 ashish 1164 
      return result.success
3431 rajveer 1165 
    if result.ex is not None:
94 ashish 1166 
      raise result.ex
1167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1168 
 
1169 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1170 
    """
1171 
    Parameters:
1172 
     - customerId
1173 
     - from_date
1174 
     - to_date
1175 
     - status
1176 
    """
1177 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1178 
    return self.recv_getTransactionsForCustomer()
1179 
 
1180 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1181 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1182 
    args = getTransactionsForCustomer_args()
1183 
    args.customerId = customerId
1184 
    args.from_date = from_date
1185 
    args.to_date = to_date
1186 
    args.status = status
1187 
    args.write(self._oprot)
1188 
    self._oprot.writeMessageEnd()
1189 
    self._oprot.trans.flush()
1190 
 
1191 
  def recv_getTransactionsForCustomer(self, ):
1192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1193 
    if mtype == TMessageType.EXCEPTION:
1194 
      x = TApplicationException()
1195 
      x.read(self._iprot)
1196 
      self._iprot.readMessageEnd()
1197 
      raise x
1198 
    result = getTransactionsForCustomer_result()
1199 
    result.read(self._iprot)
1200 
    self._iprot.readMessageEnd()
3431 rajveer 1201 
    if result.success is not None:
94 ashish 1202 
      return result.success
3431 rajveer 1203 
    if result.ex is not None:
94 ashish 1204 
      raise result.ex
1205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1206 
 
132 ashish 1207 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1208 
    """
1209 
    Parameters:
1210 
     - shoppingCartId
1211 
    """
1212 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1213 
    return self.recv_getTransactionsForShoppingCartId()
1214 
 
1215 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1216 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1217 
    args = getTransactionsForShoppingCartId_args()
1218 
    args.shoppingCartId = shoppingCartId
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_getTransactionsForShoppingCartId(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = getTransactionsForShoppingCartId_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
3431 rajveer 1233 
    if result.success is not None:
132 ashish 1234 
      return result.success
3431 rajveer 1235 
    if result.ex is not None:
132 ashish 1236 
      raise result.ex
1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1238 
 
94 ashish 1239 
  def getTransactionStatus(self, transactionId):
1240 
    """
1241 
    Parameters:
1242 
     - transactionId
1243 
    """
1244 
    self.send_getTransactionStatus(transactionId)
1245 
    return self.recv_getTransactionStatus()
1246 
 
1247 
  def send_getTransactionStatus(self, transactionId):
1248 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1249 
    args = getTransactionStatus_args()
1250 
    args.transactionId = transactionId
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getTransactionStatus(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getTransactionStatus_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
3431 rajveer 1265 
    if result.success is not None:
94 ashish 1266 
      return result.success
3431 rajveer 1267 
    if result.ex is not None:
94 ashish 1268 
      raise result.ex
1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1270 
 
1271 
  def changeTransactionStatus(self, transactionId, status, description):
1272 
    """
1273 
    Parameters:
1274 
     - transactionId
1275 
     - status
1276 
     - description
1277 
    """
1278 
    self.send_changeTransactionStatus(transactionId, status, description)
1279 
    return self.recv_changeTransactionStatus()
1280 
 
1281 
  def send_changeTransactionStatus(self, transactionId, status, description):
1282 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1283 
    args = changeTransactionStatus_args()
1284 
    args.transactionId = transactionId
1285 
    args.status = status
1286 
    args.description = description
1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_changeTransactionStatus(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = changeTransactionStatus_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
3431 rajveer 1301 
    if result.success is not None:
94 ashish 1302 
      return result.success
3431 rajveer 1303 
    if result.ex is not None:
94 ashish 1304 
      raise result.ex
1305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1306 
 
1398 varun.gupt 1307 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1308 
    """
1309 
    Parameters:
1310 
     - transactionId
1311 
    """
1398 varun.gupt 1312 
    self.send_enqueueTransactionInfoEmail(transactionId)
1313 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1314 
 
1398 varun.gupt 1315 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1316 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1317 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1318 
    args.transactionId = transactionId
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1398 varun.gupt 1323 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1398 varun.gupt 1330 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
1382 varun.gupt 1334 
      return result.success
3431 rajveer 1335 
    if result.ex is not None:
1382 varun.gupt 1336 
      raise result.ex
1398 varun.gupt 1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1338 
 
4801 anupam.sin 1339 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1340 
    """
1341 
    Parameters:
4801 anupam.sin 1342 
     - statuses
483 rajveer 1343 
     - from_date
1344 
     - to_date
1345 
     - warehouse_id
94 ashish 1346 
    """
4801 anupam.sin 1347 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1348 
    return self.recv_getAllOrders()
94 ashish 1349 
 
4801 anupam.sin 1350 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1351 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1352 
    args = getAllOrders_args()
4801 anupam.sin 1353 
    args.statuses = statuses
483 rajveer 1354 
    args.from_date = from_date
1355 
    args.to_date = to_date
1356 
    args.warehouse_id = warehouse_id
94 ashish 1357 
    args.write(self._oprot)
1358 
    self._oprot.writeMessageEnd()
1359 
    self._oprot.trans.flush()
1360 
 
483 rajveer 1361 
  def recv_getAllOrders(self, ):
94 ashish 1362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1363 
    if mtype == TMessageType.EXCEPTION:
1364 
      x = TApplicationException()
1365 
      x.read(self._iprot)
1366 
      self._iprot.readMessageEnd()
1367 
      raise x
483 rajveer 1368 
    result = getAllOrders_result()
94 ashish 1369 
    result.read(self._iprot)
1370 
    self._iprot.readMessageEnd()
3431 rajveer 1371 
    if result.success is not None:
94 ashish 1372 
      return result.success
3431 rajveer 1373 
    if result.ex is not None:
94 ashish 1374 
      raise result.ex
483 rajveer 1375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1376 
 
4133 chandransh 1377 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1378 
    """
1379 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1380 
    Pass the status as null and the limit as 0 to ignore them.
1381 
 
1382 
    Parameters:
1383 
     - statuses
1384 
     - offset
1385 
     - limit
1386 
     - warehouse_id
1387 
    """
1388 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1389 
    return self.recv_getOrdersInBatch()
1390 
 
1391 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1392 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1393 
    args = getOrdersInBatch_args()
1394 
    args.statuses = statuses
1395 
    args.offset = offset
1396 
    args.limit = limit
1397 
    args.warehouse_id = warehouse_id
1398 
    args.write(self._oprot)
1399 
    self._oprot.writeMessageEnd()
1400 
    self._oprot.trans.flush()
1401 
 
1402 
  def recv_getOrdersInBatch(self, ):
1403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1404 
    if mtype == TMessageType.EXCEPTION:
1405 
      x = TApplicationException()
1406 
      x.read(self._iprot)
1407 
      self._iprot.readMessageEnd()
1408 
      raise x
1409 
    result = getOrdersInBatch_result()
1410 
    result.read(self._iprot)
1411 
    self._iprot.readMessageEnd()
1412 
    if result.success is not None:
1413 
      return result.success
1414 
    if result.ex is not None:
1415 
      raise result.ex
1416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1417 
 
1418 
  def getOrderCount(self, statuses, warehouseId):
1419 
    """
1420 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1421 
 
1422 
    Parameters:
1423 
     - statuses
1424 
     - warehouseId
1425 
    """
1426 
    self.send_getOrderCount(statuses, warehouseId)
1427 
    return self.recv_getOrderCount()
1428 
 
1429 
  def send_getOrderCount(self, statuses, warehouseId):
1430 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1431 
    args = getOrderCount_args()
1432 
    args.statuses = statuses
1433 
    args.warehouseId = warehouseId
1434 
    args.write(self._oprot)
1435 
    self._oprot.writeMessageEnd()
1436 
    self._oprot.trans.flush()
1437 
 
1438 
  def recv_getOrderCount(self, ):
1439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1440 
    if mtype == TMessageType.EXCEPTION:
1441 
      x = TApplicationException()
1442 
      x.read(self._iprot)
1443 
      self._iprot.readMessageEnd()
1444 
      raise x
1445 
    result = getOrderCount_result()
1446 
    result.read(self._iprot)
1447 
    self._iprot.readMessageEnd()
1448 
    if result.success is not None:
1449 
      return result.success
1450 
    if result.ex is not None:
1451 
      raise result.ex
1452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1453 
 
999 varun.gupt 1454 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1455 
    """
1132 chandransh 1456 
    Returns orders within a range of their billing dates
3431 rajveer 1457 
 
999 varun.gupt 1458 
    Parameters:
1459 
     - status
1460 
     - start_billing_date
1461 
     - end_billing_date
1462 
     - warehouse_id
1463 
    """
1464 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1465 
    return self.recv_getOrdersByBillingDate()
1466 
 
1467 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1468 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1469 
    args = getOrdersByBillingDate_args()
1470 
    args.status = status
1471 
    args.start_billing_date = start_billing_date
1472 
    args.end_billing_date = end_billing_date
1473 
    args.warehouse_id = warehouse_id
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getOrdersByBillingDate(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getOrdersByBillingDate_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
3431 rajveer 1488 
    if result.success is not None:
999 varun.gupt 1489 
      return result.success
3431 rajveer 1490 
    if result.ex is not None:
999 varun.gupt 1491 
      raise result.ex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1493 
 
3451 chandransh 1494 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1495 
    """
1496 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1497 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1498 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1499 
 
3427 chandransh 1500 
    Parameters:
1501 
     - fromShippingDate
1502 
     - toShippingDate
1503 
     - providerId
1504 
     - warehouseId
3451 chandransh 1505 
     - cod
3427 chandransh 1506 
    """
3451 chandransh 1507 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1508 
    return self.recv_getOrdersByShippingDate()
1509 
 
3451 chandransh 1510 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1511 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1512 
    args = getOrdersByShippingDate_args()
1513 
    args.fromShippingDate = fromShippingDate
1514 
    args.toShippingDate = toShippingDate
1515 
    args.providerId = providerId
1516 
    args.warehouseId = warehouseId
3451 chandransh 1517 
    args.cod = cod
3427 chandransh 1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_getOrdersByShippingDate(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = getOrdersByShippingDate_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
3431 rajveer 1532 
    if result.success is not None:
3427 chandransh 1533 
      return result.success
3431 rajveer 1534 
    if result.ex is not None:
3427 chandransh 1535 
      raise result.ex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1537 
 
1382 varun.gupt 1538 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1539 
    """
1540 
    Returns order ids for orders which can be returned
3431 rajveer 1541 
 
1382 varun.gupt 1542 
    Parameters:
1543 
     - customer_id
1544 
     - limit
1545 
    """
1546 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1547 
    return self.recv_getReturnableOrdersForCustomer()
1548 
 
1549 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1550 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1551 
    args = getReturnableOrdersForCustomer_args()
1552 
    args.customer_id = customer_id
1553 
    args.limit = limit
1554 
    args.write(self._oprot)
1555 
    self._oprot.writeMessageEnd()
1556 
    self._oprot.trans.flush()
1557 
 
1558 
  def recv_getReturnableOrdersForCustomer(self, ):
1559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1560 
    if mtype == TMessageType.EXCEPTION:
1561 
      x = TApplicationException()
1562 
      x.read(self._iprot)
1563 
      self._iprot.readMessageEnd()
1564 
      raise x
1565 
    result = getReturnableOrdersForCustomer_result()
1566 
    result.read(self._iprot)
1567 
    self._iprot.readMessageEnd()
3431 rajveer 1568 
    if result.success is not None:
1382 varun.gupt 1569 
      return result.success
3431 rajveer 1570 
    if result.ex is not None:
1382 varun.gupt 1571 
      raise result.ex
1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1573 
 
1574 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1575 
    """
1576 
    Returns order ids for orders which can be cancelled
3431 rajveer 1577 
 
1382 varun.gupt 1578 
    Parameters:
1579 
     - customer_id
1580 
     - limit
1581 
    """
1582 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1583 
    return self.recv_getCancellableOrdersForCustomer()
1584 
 
1585 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1586 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1587 
    args = getCancellableOrdersForCustomer_args()
1588 
    args.customer_id = customer_id
1589 
    args.limit = limit
1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
1594 
  def recv_getCancellableOrdersForCustomer(self, ):
1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
1601 
    result = getCancellableOrdersForCustomer_result()
1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
3431 rajveer 1604 
    if result.success is not None:
1382 varun.gupt 1605 
      return result.success
3431 rajveer 1606 
    if result.ex is not None:
1382 varun.gupt 1607 
      raise result.ex
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1609 
 
483 rajveer 1610 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1611 
    """
1612 
    Parameters:
483 rajveer 1613 
     - orderId
1614 
     - status
1615 
     - description
94 ashish 1616 
    """
483 rajveer 1617 
    self.send_changeOrderStatus(orderId, status, description)
1618 
    return self.recv_changeOrderStatus()
94 ashish 1619 
 
483 rajveer 1620 
  def send_changeOrderStatus(self, orderId, status, description):
1621 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1622 
    args = changeOrderStatus_args()
1623 
    args.orderId = orderId
1624 
    args.status = status
1625 
    args.description = description
94 ashish 1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
483 rajveer 1630 
  def recv_changeOrderStatus(self, ):
94 ashish 1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
483 rajveer 1637 
    result = changeOrderStatus_result()
94 ashish 1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
3431 rajveer 1640 
    if result.success is not None:
94 ashish 1641 
      return result.success
3431 rajveer 1642 
    if result.ex is not None:
94 ashish 1643 
      raise result.ex
483 rajveer 1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1645 
 
1528 ankur.sing 1646 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1647 
    """
1528 ankur.sing 1648 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1649 
    only user who owns the transaction can view its order details.
3431 rajveer 1650 
 
94 ashish 1651 
    Parameters:
1652 
     - transactionId
1528 ankur.sing 1653 
     - customerId
94 ashish 1654 
    """
1528 ankur.sing 1655 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1656 
    return self.recv_getOrdersForTransaction()
94 ashish 1657 
 
1528 ankur.sing 1658 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1659 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1660 
    args = getOrdersForTransaction_args()
94 ashish 1661 
    args.transactionId = transactionId
1528 ankur.sing 1662 
    args.customerId = customerId
94 ashish 1663 
    args.write(self._oprot)
1664 
    self._oprot.writeMessageEnd()
1665 
    self._oprot.trans.flush()
1666 
 
483 rajveer 1667 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1669 
    if mtype == TMessageType.EXCEPTION:
1670 
      x = TApplicationException()
1671 
      x.read(self._iprot)
1672 
      self._iprot.readMessageEnd()
1673 
      raise x
483 rajveer 1674 
    result = getOrdersForTransaction_result()
94 ashish 1675 
    result.read(self._iprot)
1676 
    self._iprot.readMessageEnd()
3431 rajveer 1677 
    if result.success is not None:
94 ashish 1678 
      return result.success
3431 rajveer 1679 
    if result.ex is not None:
94 ashish 1680 
      raise result.ex
483 rajveer 1681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1682 
 
3014 chandransh 1683 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1684 
    """
3014 chandransh 1685 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1686 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1687 
 
94 ashish 1688 
    Parameters:
483 rajveer 1689 
     - customerId
1690 
     - from_date
1691 
     - to_date
3014 chandransh 1692 
     - statuses
94 ashish 1693 
    """
3014 chandransh 1694 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1695 
    return self.recv_getOrdersForCustomer()
94 ashish 1696 
 
3014 chandransh 1697 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1698 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1699 
    args = getOrdersForCustomer_args()
1700 
    args.customerId = customerId
1701 
    args.from_date = from_date
1702 
    args.to_date = to_date
3014 chandransh 1703 
    args.statuses = statuses
94 ashish 1704 
    args.write(self._oprot)
1705 
    self._oprot.writeMessageEnd()
1706 
    self._oprot.trans.flush()
1707 
 
483 rajveer 1708 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1710 
    if mtype == TMessageType.EXCEPTION:
1711 
      x = TApplicationException()
1712 
      x.read(self._iprot)
1713 
      self._iprot.readMessageEnd()
1714 
      raise x
483 rajveer 1715 
    result = getOrdersForCustomer_result()
94 ashish 1716 
    result.read(self._iprot)
1717 
    self._iprot.readMessageEnd()
3431 rajveer 1718 
    if result.success is not None:
94 ashish 1719 
      return result.success
3431 rajveer 1720 
    if result.ex is not None:
94 ashish 1721 
      raise result.ex
483 rajveer 1722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1723 
 
483 rajveer 1724 
  def createOrder(self, order):
94 ashish 1725 
    """
1726 
    Parameters:
483 rajveer 1727 
     - order
94 ashish 1728 
    """
483 rajveer 1729 
    self.send_createOrder(order)
1730 
    return self.recv_createOrder()
94 ashish 1731 
 
483 rajveer 1732 
  def send_createOrder(self, order):
1733 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1734 
    args = createOrder_args()
1735 
    args.order = order
94 ashish 1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
483 rajveer 1740 
  def recv_createOrder(self, ):
94 ashish 1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
483 rajveer 1747 
    result = createOrder_result()
94 ashish 1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
3431 rajveer 1750 
    if result.success is not None:
94 ashish 1751 
      return result.success
3431 rajveer 1752 
    if result.ex is not None:
94 ashish 1753 
      raise result.ex
483 rajveer 1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1755 
 
483 rajveer 1756 
  def getOrder(self, id):
94 ashish 1757 
    """
1758 
    Parameters:
483 rajveer 1759 
     - id
94 ashish 1760 
    """
483 rajveer 1761 
    self.send_getOrder(id)
1762 
    return self.recv_getOrder()
94 ashish 1763 
 
483 rajveer 1764 
  def send_getOrder(self, id):
1765 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1766 
    args = getOrder_args()
1767 
    args.id = id
94 ashish 1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
483 rajveer 1772 
  def recv_getOrder(self, ):
94 ashish 1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
483 rajveer 1779 
    result = getOrder_result()
94 ashish 1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
3431 rajveer 1782 
    if result.success is not None:
94 ashish 1783 
      return result.success
3431 rajveer 1784 
    if result.ex is not None:
94 ashish 1785 
      raise result.ex
483 rajveer 1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1787 
 
483 rajveer 1788 
  def getLineItemsForOrder(self, orderId):
94 ashish 1789 
    """
1790 
    Parameters:
483 rajveer 1791 
     - orderId
94 ashish 1792 
    """
483 rajveer 1793 
    self.send_getLineItemsForOrder(orderId)
1794 
    return self.recv_getLineItemsForOrder()
94 ashish 1795 
 
483 rajveer 1796 
  def send_getLineItemsForOrder(self, orderId):
1797 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1798 
    args = getLineItemsForOrder_args()
1799 
    args.orderId = orderId
94 ashish 1800 
    args.write(self._oprot)
1801 
    self._oprot.writeMessageEnd()
1802 
    self._oprot.trans.flush()
1803 
 
483 rajveer 1804 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1806 
    if mtype == TMessageType.EXCEPTION:
1807 
      x = TApplicationException()
1808 
      x.read(self._iprot)
1809 
      self._iprot.readMessageEnd()
1810 
      raise x
483 rajveer 1811 
    result = getLineItemsForOrder_result()
94 ashish 1812 
    result.read(self._iprot)
1813 
    self._iprot.readMessageEnd()
3431 rajveer 1814 
    if result.success is not None:
94 ashish 1815 
      return result.success
3431 rajveer 1816 
    if result.ex is not None:
94 ashish 1817 
      raise result.ex
483 rajveer 1818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1819 
 
1528 ankur.sing 1820 
  def getOrderForCustomer(self, orderId, customerId):
1821 
    """
1822 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1823 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1824 
 
1528 ankur.sing 1825 
    Parameters:
1826 
     - orderId
1827 
     - customerId
1828 
    """
1829 
    self.send_getOrderForCustomer(orderId, customerId)
1830 
    return self.recv_getOrderForCustomer()
1831 
 
1832 
  def send_getOrderForCustomer(self, orderId, customerId):
1833 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1834 
    args = getOrderForCustomer_args()
1835 
    args.orderId = orderId
1836 
    args.customerId = customerId
1837 
    args.write(self._oprot)
1838 
    self._oprot.writeMessageEnd()
1839 
    self._oprot.trans.flush()
1840 
 
1841 
  def recv_getOrderForCustomer(self, ):
1842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1843 
    if mtype == TMessageType.EXCEPTION:
1844 
      x = TApplicationException()
1845 
      x.read(self._iprot)
1846 
      self._iprot.readMessageEnd()
1847 
      raise x
1848 
    result = getOrderForCustomer_result()
1849 
    result.read(self._iprot)
1850 
    self._iprot.readMessageEnd()
3431 rajveer 1851 
    if result.success is not None:
1528 ankur.sing 1852 
      return result.success
3431 rajveer 1853 
    if result.ex is not None:
1528 ankur.sing 1854 
      raise result.ex
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1856 
 
4444 rajveer 1857 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1858 
    """
1859 
    Parameters:
4394 rajveer 1860 
     - type
4444 rajveer 1861 
     - warehouseId
4394 rajveer 1862 
     - status
1863 
     - timestamp
3064 chandransh 1864 
    """
4444 rajveer 1865 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1866 
    return self.recv_getAlerts()
1867 
 
4444 rajveer 1868 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1869 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1870 
    args = getAlerts_args()
4394 rajveer 1871 
    args.type = type
4444 rajveer 1872 
    args.warehouseId = warehouseId
4394 rajveer 1873 
    args.status = status
1874 
    args.timestamp = timestamp
3064 chandransh 1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_getAlerts(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = getAlerts_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
3064 chandransh 1890 
      return result.success
1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1892 
 
4444 rajveer 1893 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1894 
    """
1895 
    Parameters:
1896 
     - type
4444 rajveer 1897 
     - warehouseId
4394 rajveer 1898 
     - description
3064 chandransh 1899 
    """
4444 rajveer 1900 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1901 
    self.recv_addAlert()
3064 chandransh 1902 
 
4444 rajveer 1903 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1904 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1905 
    args = addAlert_args()
3064 chandransh 1906 
    args.type = type
4444 rajveer 1907 
    args.warehouseId = warehouseId
4394 rajveer 1908 
    args.description = description
3064 chandransh 1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
4394 rajveer 1913 
  def recv_addAlert(self, ):
3064 chandransh 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
4394 rajveer 1920 
    result = addAlert_result()
3064 chandransh 1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
1923 
    return
1924 
 
4444 rajveer 1925 
  def markAlertsAsSeen(self, warehouseId):
1926 
    """
1927 
    Parameters:
1928 
     - warehouseId
1929 
    """
1930 
    self.send_markAlertsAsSeen(warehouseId)
1931 
    self.recv_markAlertsAsSeen()
1932 
 
1933 
  def send_markAlertsAsSeen(self, warehouseId):
1934 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1935 
    args = markAlertsAsSeen_args()
1936 
    args.warehouseId = warehouseId
1937 
    args.write(self._oprot)
1938 
    self._oprot.writeMessageEnd()
1939 
    self._oprot.trans.flush()
1940 
 
1941 
  def recv_markAlertsAsSeen(self, ):
1942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1943 
    if mtype == TMessageType.EXCEPTION:
1944 
      x = TApplicationException()
1945 
      x.read(self._iprot)
1946 
      self._iprot.readMessageEnd()
1947 
      raise x
1948 
    result = markAlertsAsSeen_result()
1949 
    result.read(self._iprot)
1950 
    self._iprot.readMessageEnd()
1951 
    return
1952 
 
3064 chandransh 1953 
  def getValidOrderCount(self, ):
1954 
    """
1955 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1956 
    """
1957 
    self.send_getValidOrderCount()
1958 
    return self.recv_getValidOrderCount()
1959 
 
1960 
  def send_getValidOrderCount(self, ):
1961 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1962 
    args = getValidOrderCount_args()
1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
1967 
  def recv_getValidOrderCount(self, ):
1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
1974 
    result = getValidOrderCount_result()
1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
3431 rajveer 1977 
    if result.success is not None:
3064 chandransh 1978 
      return result.success
1979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1980 
 
1981 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1982 
    """
1983 
    Returns the number of distinct customers who have done successful transactions
1984 
    """
1985 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1986 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1987 
 
1988 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1989 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1990 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
1995 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
2002 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
3431 rajveer 2005 
    if result.success is not None:
3064 chandransh 2006 
      return result.success
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2008 
 
2009 
  def getValidOrdersAmountRange(self, ):
2010 
    """
2011 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2012 
    List contains two values, first minimum amount and second maximum amount.
2013 
    """
2014 
    self.send_getValidOrdersAmountRange()
2015 
    return self.recv_getValidOrdersAmountRange()
2016 
 
2017 
  def send_getValidOrdersAmountRange(self, ):
2018 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2019 
    args = getValidOrdersAmountRange_args()
2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
2024 
  def recv_getValidOrdersAmountRange(self, ):
2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
2031 
    result = getValidOrdersAmountRange_result()
2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
3431 rajveer 2034 
    if result.success is not None:
3064 chandransh 2035 
      return result.success
2036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2037 
 
2038 
  def getValidOrders(self, limit):
2039 
    """
2040 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2041 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2042 
 
3064 chandransh 2043 
    Parameters:
2044 
     - limit
2045 
    """
2046 
    self.send_getValidOrders(limit)
2047 
    return self.recv_getValidOrders()
2048 
 
2049 
  def send_getValidOrders(self, limit):
2050 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2051 
    args = getValidOrders_args()
2052 
    args.limit = limit
2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
2057 
  def recv_getValidOrders(self, ):
2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
2064 
    result = getValidOrders_result()
2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
3431 rajveer 2067 
    if result.success is not None:
3064 chandransh 2068 
      return result.success
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2070 
 
1220 chandransh 2071 
  def batchOrders(self, warehouseId):
2072 
    """
2073 
    Create a batch of all the pending orders for the given warehouse.
2074 
    The returned list is orderd by created_timestamp.
2075 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2076 
 
1220 chandransh 2077 
    Parameters:
2078 
     - warehouseId
2079 
    """
2080 
    self.send_batchOrders(warehouseId)
2081 
    return self.recv_batchOrders()
2082 
 
2083 
  def send_batchOrders(self, warehouseId):
2084 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2085 
    args = batchOrders_args()
2086 
    args.warehouseId = warehouseId
2087 
    args.write(self._oprot)
2088 
    self._oprot.writeMessageEnd()
2089 
    self._oprot.trans.flush()
2090 
 
2091 
  def recv_batchOrders(self, ):
2092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2093 
    if mtype == TMessageType.EXCEPTION:
2094 
      x = TApplicationException()
2095 
      x.read(self._iprot)
2096 
      self._iprot.readMessageEnd()
2097 
      raise x
2098 
    result = batchOrders_result()
2099 
    result.read(self._iprot)
2100 
    self._iprot.readMessageEnd()
3431 rajveer 2101 
    if result.success is not None:
1220 chandransh 2102 
      return result.success
3431 rajveer 2103 
    if result.ex is not None:
1220 chandransh 2104 
      raise result.ex
2105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2106 
 
1208 chandransh 2107 
  def markOrderAsOutOfStock(self, orderId):
2108 
    """
2109 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2110 
 
1208 chandransh 2111 
    Parameters:
2112 
     - orderId
2113 
    """
2114 
    self.send_markOrderAsOutOfStock(orderId)
2115 
    return self.recv_markOrderAsOutOfStock()
2116 
 
2117 
  def send_markOrderAsOutOfStock(self, orderId):
2118 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2119 
    args = markOrderAsOutOfStock_args()
2120 
    args.orderId = orderId
2121 
    args.write(self._oprot)
2122 
    self._oprot.writeMessageEnd()
2123 
    self._oprot.trans.flush()
2124 
 
2125 
  def recv_markOrderAsOutOfStock(self, ):
2126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2127 
    if mtype == TMessageType.EXCEPTION:
2128 
      x = TApplicationException()
2129 
      x.read(self._iprot)
2130 
      self._iprot.readMessageEnd()
2131 
      raise x
2132 
    result = markOrderAsOutOfStock_result()
2133 
    result.read(self._iprot)
2134 
    self._iprot.readMessageEnd()
3431 rajveer 2135 
    if result.success is not None:
1208 chandransh 2136 
      return result.success
3431 rajveer 2137 
    if result.ex is not None:
1208 chandransh 2138 
      raise result.ex
2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2140 
 
3064 chandransh 2141 
  def verifyOrder(self, orderId):
759 chandransh 2142 
    """
3064 chandransh 2143 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2144 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2145 
    used for all other orders as well.
2146 
    Throws an exception if no such order exists.
3431 rajveer 2147 
 
759 chandransh 2148 
    Parameters:
3064 chandransh 2149 
     - orderId
759 chandransh 2150 
    """
3064 chandransh 2151 
    self.send_verifyOrder(orderId)
2152 
    return self.recv_verifyOrder()
759 chandransh 2153 
 
3064 chandransh 2154 
  def send_verifyOrder(self, orderId):
2155 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2156 
    args = verifyOrder_args()
2157 
    args.orderId = orderId
759 chandransh 2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
3064 chandransh 2162 
  def recv_verifyOrder(self, ):
759 chandransh 2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
3064 chandransh 2169 
    result = verifyOrder_result()
759 chandransh 2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
3431 rajveer 2172 
    if result.success is not None:
759 chandransh 2173 
      return result.success
3431 rajveer 2174 
    if result.ex is not None:
759 chandransh 2175 
      raise result.ex
3064 chandransh 2176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2177 
 
3064 chandransh 2178 
  def acceptOrder(self, orderId):
1113 chandransh 2179 
    """
3064 chandransh 2180 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2181 
    given order is not a COD order, it also captures the payment if the same has
2182 
    not been captured.
2183 
    Throws an exception if no such order exists.
3431 rajveer 2184 
 
1113 chandransh 2185 
    Parameters:
3064 chandransh 2186 
     - orderId
1113 chandransh 2187 
    """
3064 chandransh 2188 
    self.send_acceptOrder(orderId)
2189 
    return self.recv_acceptOrder()
1113 chandransh 2190 
 
3064 chandransh 2191 
  def send_acceptOrder(self, orderId):
2192 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2193 
    args = acceptOrder_args()
2194 
    args.orderId = orderId
1113 chandransh 2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
3064 chandransh 2199 
  def recv_acceptOrder(self, ):
1113 chandransh 2200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2201 
    if mtype == TMessageType.EXCEPTION:
2202 
      x = TApplicationException()
2203 
      x.read(self._iprot)
2204 
      self._iprot.readMessageEnd()
2205 
      raise x
3064 chandransh 2206 
    result = acceptOrder_result()
1113 chandransh 2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
3431 rajveer 2209 
    if result.success is not None:
1113 chandransh 2210 
      return result.success
3431 rajveer 2211 
    if result.ex is not None:
1113 chandransh 2212 
      raise result.ex
3064 chandransh 2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2214 
 
4763 rajveer 2215 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2216 
    """
3064 chandransh 2217 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2218 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2219 
    the IMEI no. if a -1 is supplied.
2220 
    Also, it generates an invoice number for the order, marks the order as
2221 
    BILLED and sets the billing timestamp.
2222 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2223 
 
1135 chandransh 2224 
    Parameters:
3064 chandransh 2225 
     - orderId
2226 
     - invoice_number
4658 mandeep.dh 2227 
     - serialNumber
4283 anupam.sin 2228 
     - itemNumber
3064 chandransh 2229 
     - billed_by
4264 rajveer 2230 
     - jacketNumber
4283 anupam.sin 2231 
     - billingType
2232 
     - vendorId
4763 rajveer 2233 
     - authorize
1135 chandransh 2234 
    """
4763 rajveer 2235 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2236 
    return self.recv_addBillingDetails()
1135 chandransh 2237 
 
4763 rajveer 2238 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2239 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2240 
    args = addBillingDetails_args()
2241 
    args.orderId = orderId
2242 
    args.invoice_number = invoice_number
4658 mandeep.dh 2243 
    args.serialNumber = serialNumber
4283 anupam.sin 2244 
    args.itemNumber = itemNumber
3064 chandransh 2245 
    args.billed_by = billed_by
4264 rajveer 2246 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2247 
    args.billingType = billingType
2248 
    args.vendorId = vendorId
4763 rajveer 2249 
    args.authorize = authorize
1135 chandransh 2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
3064 chandransh 2254 
  def recv_addBillingDetails(self, ):
1135 chandransh 2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
3064 chandransh 2261 
    result = addBillingDetails_result()
1135 chandransh 2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
3431 rajveer 2264 
    if result.success is not None:
3064 chandransh 2265 
      return result.success
3431 rajveer 2266 
    if result.ex is not None:
1135 chandransh 2267 
      raise result.ex
3064 chandransh 2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2269 
 
4763 rajveer 2270 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2271 
    """
2272 
    Add the invoice number to the order.
2273 
 
2274 
    Parameters:
2275 
     - orderId
2276 
     - invoiceNumber
4763 rajveer 2277 
     - color
4579 rajveer 2278 
    """
4763 rajveer 2279 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2280 
    self.recv_addInvoiceNumber()
2281 
 
4763 rajveer 2282 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2283 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2284 
    args = addInvoiceNumber_args()
2285 
    args.orderId = orderId
2286 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2287 
    args.color = color
4579 rajveer 2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_addInvoiceNumber(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = addInvoiceNumber_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
2302 
    if result.ex is not None:
2303 
      raise result.ex
2304 
    return
2305 
 
4910 phani.kuma 2306 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2307 
    """
3064 chandransh 2308 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2309 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2310 
 
1408 ankur.sing 2311 
    Parameters:
3064 chandransh 2312 
     - warehouseId
1408 ankur.sing 2313 
     - providerId
3064 chandransh 2314 
     - cod
4910 phani.kuma 2315 
     - orderIds
1408 ankur.sing 2316 
    """
4910 phani.kuma 2317 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2318 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2319 
 
4910 phani.kuma 2320 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2321 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2322 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2323 
    args.warehouseId = warehouseId
1408 ankur.sing 2324 
    args.providerId = providerId
3064 chandransh 2325 
    args.cod = cod
4910 phani.kuma 2326 
    args.orderIds = orderIds
1408 ankur.sing 2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
4910 phani.kuma 2331 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
4910 phani.kuma 2338 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
3431 rajveer 2341 
    if result.success is not None:
1408 ankur.sing 2342 
      return result.success
3431 rajveer 2343 
    if result.ex is not None:
3064 chandransh 2344 
      raise result.ex
4910 phani.kuma 2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2346 
 
4910 phani.kuma 2347 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2348 
    """
4910 phani.kuma 2349 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2350 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2351 
 
2352 
    Parameters:
2353 
     - providerId
4910 phani.kuma 2354 
     - pickupDetails
4410 rajveer 2355 
    """
4910 phani.kuma 2356 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2357 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2358 
 
4910 phani.kuma 2359 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2360 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2361 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2362 
    args.providerId = providerId
4910 phani.kuma 2363 
    args.pickupDetails = pickupDetails
4410 rajveer 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
4910 phani.kuma 2368 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
4910 phani.kuma 2375 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.ex is not None:
2379 
      raise result.ex
4910 phani.kuma 2380 
    return
4410 rajveer 2381 
 
4910 phani.kuma 2382 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2383 
    """
3064 chandransh 2384 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2385 
 
94 ashish 2386 
    Parameters:
3064 chandransh 2387 
     - providerId
304 ashish 2388 
    """
4910 phani.kuma 2389 
    self.send_getOrdersNotPickedUp(providerId)
2390 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2391 
 
4910 phani.kuma 2392 
  def send_getOrdersNotPickedUp(self, providerId):
2393 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2394 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2395 
    args.providerId = providerId
304 ashish 2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
4910 phani.kuma 2400 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
4910 phani.kuma 2407 
    result = getOrdersNotPickedUp_result()
304 ashish 2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
3431 rajveer 2410 
    if result.success is not None:
304 ashish 2411 
      return result.success
4910 phani.kuma 2412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2413 
 
3064 chandransh 2414 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2415 
    """
3064 chandransh 2416 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2417 
    the name of the receiver.
2418 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2419 
 
304 ashish 2420 
    Parameters:
3064 chandransh 2421 
     - providerId
2422 
     - deliveredOrders
304 ashish 2423 
    """
3064 chandransh 2424 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2425 
    self.recv_markOrdersAsDelivered()
304 ashish 2426 
 
3064 chandransh 2427 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2428 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2429 
    args = markOrdersAsDelivered_args()
2430 
    args.providerId = providerId
2431 
    args.deliveredOrders = deliveredOrders
304 ashish 2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
3064 chandransh 2436 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
3064 chandransh 2443 
    result = markOrdersAsDelivered_result()
304 ashish 2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
3431 rajveer 2446 
    if result.ex is not None:
3064 chandransh 2447 
      raise result.ex
304 ashish 2448 
    return
2449 
 
4910 phani.kuma 2450 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2451 
    """
4910 phani.kuma 2452 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2453 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2454 
 
3064 chandransh 2455 
    Parameters:
2456 
     - providerId
2457 
     - returnedOrders
1596 ankur.sing 2458 
    """
4910 phani.kuma 2459 
    self.send_markAsRTOrders(providerId, returnedOrders)
2460 
    self.recv_markAsRTOrders()
304 ashish 2461 
 
4910 phani.kuma 2462 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2463 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2464 
    args = markAsRTOrders_args()
3064 chandransh 2465 
    args.providerId = providerId
2466 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
4910 phani.kuma 2471 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
4910 phani.kuma 2478 
    result = markAsRTOrders_result()
1596 ankur.sing 2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
3431 rajveer 2481 
    if result.ex is not None:
3064 chandransh 2482 
      raise result.ex
2483 
    return
1596 ankur.sing 2484 
 
4910 phani.kuma 2485 
  def getRTOrders(self, providerId):
2486 
    """
2487 
    Returns a list of orders that were returned by courier.
2488 
 
2489 
    Parameters:
2490 
     - providerId
2491 
    """
2492 
    self.send_getRTOrders(providerId)
2493 
    return self.recv_getRTOrders()
2494 
 
2495 
  def send_getRTOrders(self, providerId):
2496 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2497 
    args = getRTOrders_args()
2498 
    args.providerId = providerId
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_getRTOrders(self, ):
2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
2510 
    result = getRTOrders_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
2513 
    if result.success is not None:
2514 
      return result.success
2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2516 
 
3064 chandransh 2517 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2518 
    """
3064 chandransh 2519 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2520 
 
3064 chandransh 2521 
    Parameters:
2522 
     - providerId
2523 
     - undeliveredOrders
1627 ankur.sing 2524 
    """
3064 chandransh 2525 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2526 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2527 
 
3064 chandransh 2528 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2529 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2530 
    args = updateNonDeliveryReason_args()
2531 
    args.providerId = providerId
2532 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2533 
    args.write(self._oprot)
2534 
    self._oprot.writeMessageEnd()
2535 
    self._oprot.trans.flush()
2536 
 
3064 chandransh 2537 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2539 
    if mtype == TMessageType.EXCEPTION:
2540 
      x = TApplicationException()
2541 
      x.read(self._iprot)
2542 
      self._iprot.readMessageEnd()
2543 
      raise x
3064 chandransh 2544 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2545 
    result.read(self._iprot)
2546 
    self._iprot.readMessageEnd()
4910 phani.kuma 2547 
    if result.ex is not None:
2548 
      raise result.ex
2549 
    return
2550 
 
2551 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2552 
    """
2553 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2554 
 
2555 
    Parameters:
2556 
     - providerId
2557 
    """
2558 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2559 
    return self.recv_getNonDeliveredOrdersbyCourier()
2560 
 
2561 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2562 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2563 
    args = getNonDeliveredOrdersbyCourier_args()
2564 
    args.providerId = providerId
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = getNonDeliveredOrdersbyCourier_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
4581 phani.kuma 2579 
    if result.success is not None:
2580 
      return result.success
4910 phani.kuma 2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2582 
 
2583 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2584 
    """
2585 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2586 
 
2587 
    Parameters:
2588 
     - providerId
2589 
     - local_connected_orders
2590 
    """
2591 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2592 
    self.recv_markOrdersAsLocalConnected()
2593 
 
2594 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2595 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2596 
    args = markOrdersAsLocalConnected_args()
2597 
    args.providerId = providerId
2598 
    args.local_connected_orders = local_connected_orders
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_markOrdersAsLocalConnected(self, ):
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
2610 
    result = markOrdersAsLocalConnected_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.ex is not None:
3064 chandransh 2614 
      raise result.ex
4910 phani.kuma 2615 
    return
1627 ankur.sing 2616 
 
4910 phani.kuma 2617 
  def getOrdersNotLocalConnected(self, providerId):
2618 
    """
2619 
    Returns a list of orders that were picked up or shipped but pending local connection.
2620 
 
2621 
    Parameters:
2622 
     - providerId
2623 
    """
2624 
    self.send_getOrdersNotLocalConnected(providerId)
2625 
    return self.recv_getOrdersNotLocalConnected()
2626 
 
2627 
  def send_getOrdersNotLocalConnected(self, providerId):
2628 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2629 
    args = getOrdersNotLocalConnected_args()
2630 
    args.providerId = providerId
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_getOrdersNotLocalConnected(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = getOrdersNotLocalConnected_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success is not None:
2646 
      return result.success
2647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2648 
 
2649 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2650 
    """
2651 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2652 
 
2653 
    Parameters:
2654 
     - providerId
2655 
     - destination_city_reached_orders
2656 
    """
2657 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2658 
    self.recv_markOrdersAsDestinationCityReached()
2659 
 
2660 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2661 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2662 
    args = markOrdersAsDestinationCityReached_args()
2663 
    args.providerId = providerId
2664 
    args.destination_city_reached_orders = destination_city_reached_orders
2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
2669 
  def recv_markOrdersAsDestinationCityReached(self, ):
2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
2676 
    result = markOrdersAsDestinationCityReached_result()
2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    if result.ex is not None:
2680 
      raise result.ex
2681 
    return
2682 
 
2683 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2684 
    """
2685 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2686 
 
2687 
    Parameters:
2688 
     - providerId
2689 
     - first_atdl_orders
2690 
    """
2691 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2692 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2693 
 
2694 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2695 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2696 
    args = markOrdersAsFirstDeliveryAttempted_args()
2697 
    args.providerId = providerId
2698 
    args.first_atdl_orders = first_atdl_orders
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = markOrdersAsFirstDeliveryAttempted_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    if result.ex is not None:
2714 
      raise result.ex
2715 
    return
2716 
 
3064 chandransh 2717 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2718 
    """
3064 chandransh 2719 
    Returns the list of orders whose delivery time has passed but have not been
2720 
    delivered yet for the given provider and warehouse. To get a complete list of
2721 
    undelivered orders, pass them as -1.
2722 
    Returns an empty list if no such orders exist.
3431 rajveer 2723 
 
1886 ankur.sing 2724 
    Parameters:
3064 chandransh 2725 
     - providerId
2726 
     - warehouseId
1886 ankur.sing 2727 
    """
3064 chandransh 2728 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2729 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2730 
 
3064 chandransh 2731 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2732 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2733 
    args = getUndeliveredOrders_args()
2734 
    args.providerId = providerId
2735 
    args.warehouseId = warehouseId
1886 ankur.sing 2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
3064 chandransh 2740 
  def recv_getUndeliveredOrders(self, ):
1886 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 = getUndeliveredOrders_result()
1886 ankur.sing 2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
3431 rajveer 2750 
    if result.success is not None:
1886 ankur.sing 2751 
      return result.success
3064 chandransh 2752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2753 
 
4783 phani.kuma 2754 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2755 
    """
2756 
    Returns the list of orders whose expected delivery date has passed but have not been
2757 
    delivered yet.
2758 
    Returns an empty list if no such orders exist.
2759 
    """
2760 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2761 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2762 
 
2763 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2764 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2765 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
2770 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
2777 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
2780 
    if result.success is not None:
2781 
      return result.success
2782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2783 
 
2536 chandransh 2784 
  def toggleDOAFlag(self, orderId):
2785 
    """
2786 
    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.
2787 
    Returns the final flag status.
2788 
    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 2789 
 
2536 chandransh 2790 
    Parameters:
2791 
     - orderId
2792 
    """
2793 
    self.send_toggleDOAFlag(orderId)
2794 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2795 
 
2536 chandransh 2796 
  def send_toggleDOAFlag(self, orderId):
2797 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2798 
    args = toggleDOAFlag_args()
2799 
    args.orderId = orderId
2800 
    args.write(self._oprot)
2801 
    self._oprot.writeMessageEnd()
2802 
    self._oprot.trans.flush()
2803 
 
2804 
  def recv_toggleDOAFlag(self, ):
2805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2806 
    if mtype == TMessageType.EXCEPTION:
2807 
      x = TApplicationException()
2808 
      x.read(self._iprot)
2809 
      self._iprot.readMessageEnd()
2810 
      raise x
2811 
    result = toggleDOAFlag_result()
2812 
    result.read(self._iprot)
2813 
    self._iprot.readMessageEnd()
3431 rajveer 2814 
    if result.success is not None:
2536 chandransh 2815 
      return result.success
3431 rajveer 2816 
    if result.ex is not None:
2536 chandransh 2817 
      raise result.ex
2818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2819 
 
4712 rajveer 2820 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2821 
    """
2822 
    Parameters:
2823 
     - orderId
2824 
     - deliveryTimestamp
2825 
     - receiver
2826 
    """
2827 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2828 
    self.recv_markOrderAsDelivered()
2829 
 
2830 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2831 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2832 
    args = markOrderAsDelivered_args()
2833 
    args.orderId = orderId
2834 
    args.deliveryTimestamp = deliveryTimestamp
2835 
    args.receiver = receiver
2836 
    args.write(self._oprot)
2837 
    self._oprot.writeMessageEnd()
2838 
    self._oprot.trans.flush()
2839 
 
2840 
  def recv_markOrderAsDelivered(self, ):
2841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2842 
    if mtype == TMessageType.EXCEPTION:
2843 
      x = TApplicationException()
2844 
      x.read(self._iprot)
2845 
      self._iprot.readMessageEnd()
2846 
      raise x
2847 
    result = markOrderAsDelivered_result()
2848 
    result.read(self._iprot)
2849 
    self._iprot.readMessageEnd()
2850 
    if result.ex is not None:
2851 
      raise result.ex
2852 
    return
2853 
 
4454 rajveer 2854 
  def markOrderDoaRequestReceived(self, orderId):
2855 
    """
2856 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2857 
 
2858 
    Parameters:
2859 
     - orderId
2860 
    """
2861 
    self.send_markOrderDoaRequestReceived(orderId)
2862 
    return self.recv_markOrderDoaRequestReceived()
2863 
 
2864 
  def send_markOrderDoaRequestReceived(self, orderId):
2865 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2866 
    args = markOrderDoaRequestReceived_args()
2867 
    args.orderId = orderId
2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
2872 
  def recv_markOrderDoaRequestReceived(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 = markOrderDoaRequestReceived_result()
2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
2882 
    if result.success is not None:
2883 
      return result.success
2884 
    if result.ex is not None:
2885 
      raise result.ex
2886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2887 
 
2888 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2889 
    """
2890 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2891 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2892 
 
2893 
    Parameters:
2894 
     - orderId
2895 
     - isAuthorized
2896 
    """
2897 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2898 
    return self.recv_markOrderDoaRequestAuthorized()
2899 
 
2900 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2901 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2902 
    args = markOrderDoaRequestAuthorized_args()
2903 
    args.orderId = orderId
2904 
    args.isAuthorized = isAuthorized
2905 
    args.write(self._oprot)
2906 
    self._oprot.writeMessageEnd()
2907 
    self._oprot.trans.flush()
2908 
 
2909 
  def recv_markOrderDoaRequestAuthorized(self, ):
2910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2911 
    if mtype == TMessageType.EXCEPTION:
2912 
      x = TApplicationException()
2913 
      x.read(self._iprot)
2914 
      self._iprot.readMessageEnd()
2915 
      raise x
2916 
    result = markOrderDoaRequestAuthorized_result()
2917 
    result.read(self._iprot)
2918 
    self._iprot.readMessageEnd()
2919 
    if result.success is not None:
2920 
      return result.success
2921 
    if result.ex is not None:
2922 
      raise result.ex
2923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2924 
 
4488 rajveer 2925 
  def markOrderReturnRequestReceived(self, orderId):
2926 
    """
2927 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2928 
 
2929 
    Parameters:
2930 
     - orderId
2931 
    """
2932 
    self.send_markOrderReturnRequestReceived(orderId)
2933 
    return self.recv_markOrderReturnRequestReceived()
2934 
 
2935 
  def send_markOrderReturnRequestReceived(self, orderId):
2936 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2937 
    args = markOrderReturnRequestReceived_args()
2938 
    args.orderId = orderId
2939 
    args.write(self._oprot)
2940 
    self._oprot.writeMessageEnd()
2941 
    self._oprot.trans.flush()
2942 
 
2943 
  def recv_markOrderReturnRequestReceived(self, ):
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
2950 
    result = markOrderReturnRequestReceived_result()
2951 
    result.read(self._iprot)
2952 
    self._iprot.readMessageEnd()
2953 
    if result.success is not None:
2954 
      return result.success
2955 
    if result.ex is not None:
2956 
      raise result.ex
2957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2958 
 
2959 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2960 
    """
2961 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2962 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2963 
 
2964 
    Parameters:
2965 
     - orderId
2966 
     - isAuthorized
2967 
    """
2968 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2969 
    return self.recv_markOrderReturnRequestAuthorized()
2970 
 
2971 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2972 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2973 
    args = markOrderReturnRequestAuthorized_args()
2974 
    args.orderId = orderId
2975 
    args.isAuthorized = isAuthorized
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_markOrderReturnRequestAuthorized(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = markOrderReturnRequestAuthorized_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    if result.ex is not None:
2993 
      raise result.ex
2994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2995 
 
4579 rajveer 2996 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2997 
    """
2998 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2999 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3000 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3001 
    For any other status, it returns false.
3002 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3003 
 
2536 chandransh 3004 
    Parameters:
3005 
     - orderId
4579 rajveer 3006 
     - providerId
2536 chandransh 3007 
    """
4579 rajveer 3008 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3009 
    return self.recv_requestPickupNumber()
3010 
 
4579 rajveer 3011 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3012 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3013 
    args = requestPickupNumber_args()
3014 
    args.orderId = orderId
4579 rajveer 3015 
    args.providerId = providerId
2536 chandransh 3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3020 
  def recv_requestPickupNumber(self, ):
3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3027 
    result = requestPickupNumber_result()
3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
3431 rajveer 3030 
    if result.success is not None:
2536 chandransh 3031 
      return result.success
3431 rajveer 3032 
    if result.ex is not None:
2536 chandransh 3033 
      raise result.ex
3034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3035 
 
4602 rajveer 3036 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3037 
    """
4452 rajveer 3038 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3039 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3040 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3041 
    	3. Returns true
2591 chandransh 3042 
    If the order is in any other status, it returns false.
2536 chandransh 3043 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3044 
 
2536 chandransh 3045 
    Parameters:
3046 
     - orderId
3047 
     - pickupNumber
4602 rajveer 3048 
     - providerId
2536 chandransh 3049 
    """
4602 rajveer 3050 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3051 
    return self.recv_authorizePickup()
3052 
 
4602 rajveer 3053 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3054 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3055 
    args = authorizePickup_args()
3056 
    args.orderId = orderId
3057 
    args.pickupNumber = pickupNumber
4602 rajveer 3058 
    args.providerId = providerId
2536 chandransh 3059 
    args.write(self._oprot)
3060 
    self._oprot.writeMessageEnd()
3061 
    self._oprot.trans.flush()
3062 
 
3063 
  def recv_authorizePickup(self, ):
3064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3065 
    if mtype == TMessageType.EXCEPTION:
3066 
      x = TApplicationException()
3067 
      x.read(self._iprot)
3068 
      self._iprot.readMessageEnd()
3069 
      raise x
3070 
    result = authorizePickup_result()
3071 
    result.read(self._iprot)
3072 
    self._iprot.readMessageEnd()
3431 rajveer 3073 
    if result.success is not None:
2536 chandransh 3074 
      return result.success
3431 rajveer 3075 
    if result.ex is not None:
2536 chandransh 3076 
      raise result.ex
3077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3078 
 
2764 chandransh 3079 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3080 
    """
3081 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3082 
 
2764 chandransh 3083 
    Parameters:
3084 
     - providerId
3085 
     - pickupDetails
3086 
    """
3087 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3088 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3089 
 
3090 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3091 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3092 
    args = markDoasAsPickedUp_args()
3093 
    args.providerId = providerId
3094 
    args.pickupDetails = pickupDetails
3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3099 
  def recv_markDoasAsPickedUp(self, ):
3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3106 
    result = markDoasAsPickedUp_result()
3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
4910 phani.kuma 3109 
    return
3110 
 
3111 
  def getDoasNotPickedUp(self, providerId):
3112 
    """
3113 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3114 
 
3115 
    Parameters:
3116 
     - providerId
3117 
    """
3118 
    self.send_getDoasNotPickedUp(providerId)
3119 
    return self.recv_getDoasNotPickedUp()
3120 
 
3121 
  def send_getDoasNotPickedUp(self, providerId):
3122 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3123 
    args = getDoasNotPickedUp_args()
3124 
    args.providerId = providerId
3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_getDoasNotPickedUp(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = getDoasNotPickedUp_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
3431 rajveer 3139 
    if result.success is not None:
2764 chandransh 3140 
      return result.success
4910 phani.kuma 3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3142 
 
4741 phani.kuma 3143 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3144 
    """
3145 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3146 
 
3147 
    Parameters:
3148 
     - providerId
3149 
     - pickupDetails
3150 
    """
3151 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3152 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3153 
 
3154 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3155 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3156 
    args = markReturnOrdersAsPickedUp_args()
3157 
    args.providerId = providerId
3158 
    args.pickupDetails = pickupDetails
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_markReturnOrdersAsPickedUp(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = markReturnOrdersAsPickedUp_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
4910 phani.kuma 3173 
    return
3174 
 
3175 
  def getReturnOrdersNotPickedUp(self, providerId):
3176 
    """
3177 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3178 
 
3179 
    Parameters:
3180 
     - providerId
3181 
    """
3182 
    self.send_getReturnOrdersNotPickedUp(providerId)
3183 
    return self.recv_getReturnOrdersNotPickedUp()
3184 
 
3185 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3186 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3187 
    args = getReturnOrdersNotPickedUp_args()
3188 
    args.providerId = providerId
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_getReturnOrdersNotPickedUp(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = getReturnOrdersNotPickedUp_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
4741 phani.kuma 3203 
    if result.success is not None:
3204 
      return result.success
4910 phani.kuma 3205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3206 
 
4479 rajveer 3207 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3208 
    """
4452 rajveer 3209 
    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 3210 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3211 
    If the order is in any other state, it returns false.
3212 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3213 
 
2591 chandransh 3214 
    Parameters:
3215 
     - orderId
4479 rajveer 3216 
     - receiveCondition
2591 chandransh 3217 
    """
4479 rajveer 3218 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3219 
    return self.recv_receiveReturn()
2536 chandransh 3220 
 
4479 rajveer 3221 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3222 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3223 
    args = receiveReturn_args()
2591 chandransh 3224 
    args.orderId = orderId
4479 rajveer 3225 
    args.receiveCondition = receiveCondition
2591 chandransh 3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
2616 chandransh 3230 
  def recv_receiveReturn(self, ):
2591 chandransh 3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
2616 chandransh 3237 
    result = receiveReturn_result()
2591 chandransh 3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3431 rajveer 3240 
    if result.success is not None:
2591 chandransh 3241 
      return result.success
3431 rajveer 3242 
    if result.ex is not None:
2591 chandransh 3243 
      raise result.ex
2616 chandransh 3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3245 
 
3246 
  def validateDoa(self, orderId, isValid):
3247 
    """
4452 rajveer 3248 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3249 
    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 3250 
    If the order is in any other state, it returns false.
3251 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3252 
 
2591 chandransh 3253 
    Parameters:
3254 
     - orderId
3255 
     - isValid
3256 
    """
3257 
    self.send_validateDoa(orderId, isValid)
3258 
    return self.recv_validateDoa()
3259 
 
3260 
  def send_validateDoa(self, orderId, isValid):
3261 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3262 
    args = validateDoa_args()
3263 
    args.orderId = orderId
3264 
    args.isValid = isValid
3265 
    args.write(self._oprot)
3266 
    self._oprot.writeMessageEnd()
3267 
    self._oprot.trans.flush()
3268 
 
3269 
  def recv_validateDoa(self, ):
3270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3271 
    if mtype == TMessageType.EXCEPTION:
3272 
      x = TApplicationException()
3273 
      x.read(self._iprot)
3274 
      self._iprot.readMessageEnd()
3275 
      raise x
3276 
    result = validateDoa_result()
3277 
    result.read(self._iprot)
3278 
    self._iprot.readMessageEnd()
3431 rajveer 3279 
    if result.success is not None:
2591 chandransh 3280 
      return result.success
3431 rajveer 3281 
    if result.ex is not None:
2591 chandransh 3282 
      raise result.ex
3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3284 
 
4495 rajveer 3285 
  def validateReturnProduct(self, orderId, isUsable):
3286 
    """
3287 
    Parameters:
3288 
     - orderId
3289 
     - isUsable
3290 
    """
3291 
    self.send_validateReturnProduct(orderId, isUsable)
3292 
    return self.recv_validateReturnProduct()
3293 
 
3294 
  def send_validateReturnProduct(self, orderId, isUsable):
3295 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3296 
    args = validateReturnProduct_args()
3297 
    args.orderId = orderId
3298 
    args.isUsable = isUsable
3299 
    args.write(self._oprot)
3300 
    self._oprot.writeMessageEnd()
3301 
    self._oprot.trans.flush()
3302 
 
3303 
  def recv_validateReturnProduct(self, ):
3304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3305 
    if mtype == TMessageType.EXCEPTION:
3306 
      x = TApplicationException()
3307 
      x.read(self._iprot)
3308 
      self._iprot.readMessageEnd()
3309 
      raise x
3310 
    result = validateReturnProduct_result()
3311 
    result.read(self._iprot)
3312 
    self._iprot.readMessageEnd()
3313 
    if result.success is not None:
3314 
      return result.success
3315 
    if result.ex is not None:
3316 
      raise result.ex
3317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3318 
 
2616 chandransh 3319 
  def reshipOrder(self, orderId):
3320 
    """
4484 rajveer 3321 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3322 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3323 
    	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 3324 
 
3325 
    If the order is in DOA_CERT_VALID state, it does the following:
3326 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3327 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3328 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3329 
 
2616 chandransh 3330 
    Returns the id of the newly created order.
3431 rajveer 3331 
 
2616 chandransh 3332 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3333 
 
2616 chandransh 3334 
    Parameters:
3335 
     - orderId
3336 
    """
3337 
    self.send_reshipOrder(orderId)
3338 
    return self.recv_reshipOrder()
2591 chandransh 3339 
 
2616 chandransh 3340 
  def send_reshipOrder(self, orderId):
3341 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3342 
    args = reshipOrder_args()
3343 
    args.orderId = orderId
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_reshipOrder(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = reshipOrder_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3431 rajveer 3358 
    if result.success is not None:
2616 chandransh 3359 
      return result.success
3431 rajveer 3360 
    if result.ex is not None:
2616 chandransh 3361 
      raise result.ex
3362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3363 
 
3226 chandransh 3364 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3365 
    """
4484 rajveer 3366 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3367 
    	1. Creates a refund request for batch processing.
3368 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3369 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3370 
 
2616 chandransh 3371 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3372 
    	1. Creates a refund request for batch processing.
3226 chandransh 3373 
    	2. Cancels the reservation of the item in the warehouse.
3374 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3375 
 
3226 chandransh 3376 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3377 
    	1. Cancels the reservation of the item in the warehouse.
3378 
    	2. Marks the current order as CANCELED.
3379 
 
3380 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3381 
 
2616 chandransh 3382 
    Returns True if it is successful, False otherwise.
3431 rajveer 3383 
 
2616 chandransh 3384 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3385 
 
2616 chandransh 3386 
    Parameters:
3387 
     - orderId
3226 chandransh 3388 
     - refundedBy
3389 
     - reason
2616 chandransh 3390 
    """
3226 chandransh 3391 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3392 
    return self.recv_refundOrder()
3393 
 
3226 chandransh 3394 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3395 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3396 
    args = refundOrder_args()
3397 
    args.orderId = orderId
3226 chandransh 3398 
    args.refundedBy = refundedBy
3399 
    args.reason = reason
2616 chandransh 3400 
    args.write(self._oprot)
3401 
    self._oprot.writeMessageEnd()
3402 
    self._oprot.trans.flush()
3403 
 
3404 
  def recv_refundOrder(self, ):
3405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3406 
    if mtype == TMessageType.EXCEPTION:
3407 
      x = TApplicationException()
3408 
      x.read(self._iprot)
3409 
      self._iprot.readMessageEnd()
3410 
      raise x
3411 
    result = refundOrder_result()
3412 
    result.read(self._iprot)
3413 
    self._iprot.readMessageEnd()
3431 rajveer 3414 
    if result.success is not None:
2616 chandransh 3415 
      return result.success
3431 rajveer 3416 
    if result.ex is not None:
2616 chandransh 3417 
      raise result.ex
3418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3419 
 
2690 chandransh 3420 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3421 
    """
3422 
    Get all return orders created between the from and to dates for the given warehouse.
3423 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3424 
 
2690 chandransh 3425 
    Parameters:
3426 
     - warehouseId
3427 
     - fromDate
3428 
     - toDate
3429 
    """
3430 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3431 
    return self.recv_getReturnOrders()
2616 chandransh 3432 
 
2690 chandransh 3433 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3434 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3435 
    args = getReturnOrders_args()
3436 
    args.warehouseId = warehouseId
3437 
    args.fromDate = fromDate
3438 
    args.toDate = toDate
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_getReturnOrders(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = getReturnOrders_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3431 rajveer 3453 
    if result.success is not None:
2690 chandransh 3454 
      return result.success
3455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3456 
 
2700 chandransh 3457 
  def getReturnOrder(self, id):
3458 
    """
3459 
    Returns the ReturnOrder corresponding to the given id.
3460 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3461 
 
2700 chandransh 3462 
    Parameters:
3463 
     - id
3464 
    """
3465 
    self.send_getReturnOrder(id)
3466 
    return self.recv_getReturnOrder()
3467 
 
3468 
  def send_getReturnOrder(self, id):
3469 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3470 
    args = getReturnOrder_args()
3471 
    args.id = id
3472 
    args.write(self._oprot)
3473 
    self._oprot.writeMessageEnd()
3474 
    self._oprot.trans.flush()
3475 
 
3476 
  def recv_getReturnOrder(self, ):
3477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3478 
    if mtype == TMessageType.EXCEPTION:
3479 
      x = TApplicationException()
3480 
      x.read(self._iprot)
3481 
      self._iprot.readMessageEnd()
3482 
      raise x
3483 
    result = getReturnOrder_result()
3484 
    result.read(self._iprot)
3485 
    self._iprot.readMessageEnd()
3431 rajveer 3486 
    if result.success is not None:
2700 chandransh 3487 
      return result.success
3431 rajveer 3488 
    if result.ex is not None:
2700 chandransh 3489 
      raise result.ex
3490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3491 
 
2690 chandransh 3492 
  def processReturn(self, returnOrderId):
3493 
    """
3494 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3495 
 
2690 chandransh 3496 
    Parameters:
3497 
     - returnOrderId
3498 
    """
3499 
    self.send_processReturn(returnOrderId)
3500 
    self.recv_processReturn()
3501 
 
3502 
  def send_processReturn(self, returnOrderId):
3503 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3504 
    args = processReturn_args()
3505 
    args.returnOrderId = returnOrderId
3506 
    args.write(self._oprot)
3507 
    self._oprot.writeMessageEnd()
3508 
    self._oprot.trans.flush()
3509 
 
3510 
  def recv_processReturn(self, ):
3511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3512 
    if mtype == TMessageType.EXCEPTION:
3513 
      x = TApplicationException()
3514 
      x.read(self._iprot)
3515 
      self._iprot.readMessageEnd()
3516 
      raise x
3517 
    result = processReturn_result()
3518 
    result.read(self._iprot)
3519 
    self._iprot.readMessageEnd()
3431 rajveer 3520 
    if result.ex is not None:
2690 chandransh 3521 
      raise result.ex
3522 
    return
3523 
 
3451 chandransh 3524 
  def updateWeight(self, orderId, weight):
3525 
    """
3526 
    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 3527 
 
3451 chandransh 3528 
    Parameters:
3529 
     - orderId
3530 
     - weight
3531 
    """
3532 
    self.send_updateWeight(orderId, weight)
3533 
    return self.recv_updateWeight()
3534 
 
3535 
  def send_updateWeight(self, orderId, weight):
3536 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3537 
    args = updateWeight_args()
3538 
    args.orderId = orderId
3539 
    args.weight = weight
3540 
    args.write(self._oprot)
3541 
    self._oprot.writeMessageEnd()
3542 
    self._oprot.trans.flush()
3543 
 
3544 
  def recv_updateWeight(self, ):
3545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3546 
    if mtype == TMessageType.EXCEPTION:
3547 
      x = TApplicationException()
3548 
      x.read(self._iprot)
3549 
      self._iprot.readMessageEnd()
3550 
      raise x
3551 
    result = updateWeight_result()
3552 
    result.read(self._iprot)
3553 
    self._iprot.readMessageEnd()
3554 
    if result.success is not None:
3555 
      return result.success
3556 
    if result.ex is not None:
3557 
      raise result.ex
3558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3559 
 
3469 chandransh 3560 
  def changeItem(self, orderId, itemId):
3561 
    """
3562 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3563 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3564 
 
3469 chandransh 3565 
    Parameters:
3566 
     - orderId
3567 
     - itemId
3568 
    """
3569 
    self.send_changeItem(orderId, itemId)
3570 
    return self.recv_changeItem()
3571 
 
3572 
  def send_changeItem(self, orderId, itemId):
3573 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3574 
    args = changeItem_args()
3575 
    args.orderId = orderId
3576 
    args.itemId = itemId
3577 
    args.write(self._oprot)
3578 
    self._oprot.writeMessageEnd()
3579 
    self._oprot.trans.flush()
3580 
 
3581 
  def recv_changeItem(self, ):
3582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3583 
    if mtype == TMessageType.EXCEPTION:
3584 
      x = TApplicationException()
3585 
      x.read(self._iprot)
3586 
      self._iprot.readMessageEnd()
3587 
      raise x
3588 
    result = changeItem_result()
3589 
    result.read(self._iprot)
3590 
    self._iprot.readMessageEnd()
3591 
    if result.success is not None:
3592 
      return result.success
3593 
    if result.ex is not None:
3594 
      raise result.ex
3595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3596 
 
3597 
  def shiftToWarehouse(self, orderId, warehouseId):
3598 
    """
3599 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3600 
 
3601 
    Parameters:
3602 
     - orderId
3603 
     - warehouseId
3604 
    """
3605 
    self.send_shiftToWarehouse(orderId, warehouseId)
3606 
    return self.recv_shiftToWarehouse()
3607 
 
3608 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3609 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3610 
    args = shiftToWarehouse_args()
3611 
    args.orderId = orderId
3612 
    args.warehouseId = warehouseId
3613 
    args.write(self._oprot)
3614 
    self._oprot.writeMessageEnd()
3615 
    self._oprot.trans.flush()
3616 
 
3617 
  def recv_shiftToWarehouse(self, ):
3618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3619 
    if mtype == TMessageType.EXCEPTION:
3620 
      x = TApplicationException()
3621 
      x.read(self._iprot)
3622 
      self._iprot.readMessageEnd()
3623 
      raise x
3624 
    result = shiftToWarehouse_result()
3625 
    result.read(self._iprot)
3626 
    self._iprot.readMessageEnd()
3627 
    if result.success is not None:
3628 
      return result.success
3629 
    if result.ex is not None:
3630 
      raise result.ex
3631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3632 
 
4647 rajveer 3633 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3634 
    """
3635 
    Adds the given delay reason to the given order.
3986 chandransh 3636 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3637 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3638 
 
3553 chandransh 3639 
    Parameters:
3640 
     - orderId
3641 
     - delayReason
3986 chandransh 3642 
     - furtherDelay
4647 rajveer 3643 
     - delayReasonText
3553 chandransh 3644 
    """
4647 rajveer 3645 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3646 
    return self.recv_addDelayReason()
3647 
 
4647 rajveer 3648 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3649 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3650 
    args = addDelayReason_args()
3651 
    args.orderId = orderId
3652 
    args.delayReason = delayReason
3986 chandransh 3653 
    args.furtherDelay = furtherDelay
4647 rajveer 3654 
    args.delayReasonText = delayReasonText
3553 chandransh 3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
3659 
  def recv_addDelayReason(self, ):
3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
3666 
    result = addDelayReason_result()
3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3669 
    if result.success is not None:
3670 
      return result.success
3671 
    if result.ex is not None:
3672 
      raise result.ex
3673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3674 
 
3956 chandransh 3675 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3676 
    """
3677 
    Marks the COD orders with given AWB nos. as having been processed.
3678 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3679 
 
3956 chandransh 3680 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3681 
    1. There is no order corresponding to an AWB number.
3682 
    2. The captured amount for a payment exceeds the total payment.
3683 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3684 
 
3685 
    Parameters:
3686 
     - collectedAmountMap
3687 
     - xferBy
3688 
     - xferTxnId
3689 
     - xferDate
3690 
    """
3691 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3692 
    return self.recv_reconcileCodCollection()
3693 
 
3694 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3695 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3696 
    args = reconcileCodCollection_args()
3697 
    args.collectedAmountMap = collectedAmountMap
3698 
    args.xferBy = xferBy
3699 
    args.xferTxnId = xferTxnId
3700 
    args.xferDate = xferDate
3701 
    args.write(self._oprot)
3702 
    self._oprot.writeMessageEnd()
3703 
    self._oprot.trans.flush()
3704 
 
3705 
  def recv_reconcileCodCollection(self, ):
3706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3707 
    if mtype == TMessageType.EXCEPTION:
3708 
      x = TApplicationException()
3709 
      x.read(self._iprot)
3710 
      self._iprot.readMessageEnd()
3711 
      raise x
3712 
    result = reconcileCodCollection_result()
3713 
    result.read(self._iprot)
3714 
    self._iprot.readMessageEnd()
3715 
    if result.success is not None:
3716 
      return result.success
3717 
    if result.ex is not None:
3718 
      raise result.ex
3719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3720 
 
4008 mandeep.dh 3721 
  def getTransactionsRequiringExtraProcessing(self, category):
3722 
    """
4065 mandeep.dh 3723 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3724 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3725 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3726 
 
4008 mandeep.dh 3727 
    Parameters:
3728 
     - category
3729 
    """
3730 
    self.send_getTransactionsRequiringExtraProcessing(category)
3731 
    return self.recv_getTransactionsRequiringExtraProcessing()
3732 
 
3733 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3734 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3735 
    args = getTransactionsRequiringExtraProcessing_args()
3736 
    args.category = category
3737 
    args.write(self._oprot)
3738 
    self._oprot.writeMessageEnd()
3739 
    self._oprot.trans.flush()
3740 
 
3741 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3743 
    if mtype == TMessageType.EXCEPTION:
3744 
      x = TApplicationException()
3745 
      x.read(self._iprot)
3746 
      self._iprot.readMessageEnd()
3747 
      raise x
3748 
    result = getTransactionsRequiringExtraProcessing_result()
3749 
    result.read(self._iprot)
3750 
    self._iprot.readMessageEnd()
3751 
    if result.success is not None:
3752 
      return result.success
3753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3754 
 
3755 
  def markTransactionAsProcessed(self, transactionId, category):
3756 
    """
3757 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3758 
    It essentially deletes the transaction id record for a particular
3759 
    processing type category (if present) from DB.
3760 
    This is currently used by CRM application.
4008 mandeep.dh 3761 
 
3762 
    Parameters:
3763 
     - transactionId
3764 
     - category
3765 
    """
3766 
    self.send_markTransactionAsProcessed(transactionId, category)
3767 
    self.recv_markTransactionAsProcessed()
3768 
 
3769 
  def send_markTransactionAsProcessed(self, transactionId, category):
3770 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3771 
    args = markTransactionAsProcessed_args()
3772 
    args.transactionId = transactionId
3773 
    args.category = category
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_markTransactionAsProcessed(self, ):
3779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3780 
    if mtype == TMessageType.EXCEPTION:
3781 
      x = TApplicationException()
3782 
      x.read(self._iprot)
3783 
      self._iprot.readMessageEnd()
3784 
      raise x
3785 
    result = markTransactionAsProcessed_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3788 
    return
3789 
 
4018 chandransh 3790 
  def getItemWiseRiskyOrdersCount(self, ):
3791 
    """
3792 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3793 
    is defined as one whose shipping date is about to expire.
3794 
    """
3795 
    self.send_getItemWiseRiskyOrdersCount()
3796 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3797 
 
4018 chandransh 3798 
  def send_getItemWiseRiskyOrdersCount(self, ):
3799 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3800 
    args = getItemWiseRiskyOrdersCount_args()
3801 
    args.write(self._oprot)
3802 
    self._oprot.writeMessageEnd()
3803 
    self._oprot.trans.flush()
3804 
 
3805 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3807 
    if mtype == TMessageType.EXCEPTION:
3808 
      x = TApplicationException()
3809 
      x.read(self._iprot)
3810 
      self._iprot.readMessageEnd()
3811 
      raise x
3812 
    result = getItemWiseRiskyOrdersCount_result()
3813 
    result.read(self._iprot)
3814 
    self._iprot.readMessageEnd()
3815 
    if result.success is not None:
3816 
      return result.success
3817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3818 
 
4295 varun.gupt 3819 
  def getOrdersForItemIds(self, itemIds):
3820 
    """
3821 
    Returns a list of all orders which have items with given id
3822 
 
3823 
    Parameters:
3824 
     - itemIds
3825 
    """
3826 
    self.send_getOrdersForItemIds(itemIds)
3827 
    return self.recv_getOrdersForItemIds()
3828 
 
3829 
  def send_getOrdersForItemIds(self, itemIds):
3830 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3831 
    args = getOrdersForItemIds_args()
3832 
    args.itemIds = itemIds
3833 
    args.write(self._oprot)
3834 
    self._oprot.writeMessageEnd()
3835 
    self._oprot.trans.flush()
3836 
 
3837 
  def recv_getOrdersForItemIds(self, ):
3838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3839 
    if mtype == TMessageType.EXCEPTION:
3840 
      x = TApplicationException()
3841 
      x.read(self._iprot)
3842 
      self._iprot.readMessageEnd()
3843 
      raise x
3844 
    result = getOrdersForItemIds_result()
3845 
    result.read(self._iprot)
3846 
    self._iprot.readMessageEnd()
3847 
    if result.success is not None:
3848 
      return result.success
3849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3850 
 
4247 rajveer 3851 
  def markOrderCancellationRequestReceived(self, orderId):
3852 
    """
3853 
    Mark order as cancellation request received. If customer sends request of cancellation of
3854 
    a particular order, this method will be called. It will just change status of the order
3855 
    depending on its current status. It also records the previous status, so that we can move
3856 
    back to that status if cancellation request is denied.
4018 chandransh 3857 
 
4247 rajveer 3858 
    Parameters:
3859 
     - orderId
3860 
    """
3861 
    self.send_markOrderCancellationRequestReceived(orderId)
3862 
    self.recv_markOrderCancellationRequestReceived()
3863 
 
3864 
  def send_markOrderCancellationRequestReceived(self, orderId):
3865 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3866 
    args = markOrderCancellationRequestReceived_args()
3867 
    args.orderId = orderId
3868 
    args.write(self._oprot)
3869 
    self._oprot.writeMessageEnd()
3870 
    self._oprot.trans.flush()
3871 
 
3872 
  def recv_markOrderCancellationRequestReceived(self, ):
3873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3874 
    if mtype == TMessageType.EXCEPTION:
3875 
      x = TApplicationException()
3876 
      x.read(self._iprot)
3877 
      self._iprot.readMessageEnd()
3878 
      raise x
3879 
    result = markOrderCancellationRequestReceived_result()
3880 
    result.read(self._iprot)
3881 
    self._iprot.readMessageEnd()
3882 
    if result.ex is not None:
3883 
      raise result.ex
3884 
    return
3885 
 
3886 
  def markOrderCancellationRequestConfirmed(self, orderId):
3887 
    """
3888 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3889 
    cancellation request confirmed. After this OM will be able to cancel the order.
3890 
 
3891 
    Parameters:
3892 
     - orderId
3893 
    """
3894 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3895 
    self.recv_markOrderCancellationRequestConfirmed()
3896 
 
3897 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3898 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3899 
    args = markOrderCancellationRequestConfirmed_args()
3900 
    args.orderId = orderId
3901 
    args.write(self._oprot)
3902 
    self._oprot.writeMessageEnd()
3903 
    self._oprot.trans.flush()
3904 
 
3905 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3907 
    if mtype == TMessageType.EXCEPTION:
3908 
      x = TApplicationException()
3909 
      x.read(self._iprot)
3910 
      self._iprot.readMessageEnd()
3911 
      raise x
3912 
    result = markOrderCancellationRequestConfirmed_result()
3913 
    result.read(self._iprot)
3914 
    self._iprot.readMessageEnd()
3915 
    if result.ex is not None:
3916 
      raise result.ex
3917 
    return
3918 
 
3919 
  def markOrderCancellationRequestDenied(self, orderId):
3920 
    """
3921 
    If we decide to not to cancel order, we will move the order ro previous status.
3922 
 
3923 
    Parameters:
3924 
     - orderId
3925 
    """
3926 
    self.send_markOrderCancellationRequestDenied(orderId)
3927 
    self.recv_markOrderCancellationRequestDenied()
3928 
 
3929 
  def send_markOrderCancellationRequestDenied(self, orderId):
3930 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3931 
    args = markOrderCancellationRequestDenied_args()
3932 
    args.orderId = orderId
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_markOrderCancellationRequestDenied(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = markOrderCancellationRequestDenied_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    if result.ex is not None:
3948 
      raise result.ex
3949 
    return
3950 
 
4258 rajveer 3951 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3952 
    """
4258 rajveer 3953 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3954 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3955 
 
3956 
    Parameters:
4258 rajveer 3957 
     - transactionId
4247 rajveer 3958 
    """
4258 rajveer 3959 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3960 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3961 
 
4258 rajveer 3962 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3963 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3964 
    args = markTransactionAsPaymentFlagRemoved_args()
3965 
    args.transactionId = transactionId
4247 rajveer 3966 
    args.write(self._oprot)
3967 
    self._oprot.writeMessageEnd()
3968 
    self._oprot.trans.flush()
3969 
 
4258 rajveer 3970 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3972 
    if mtype == TMessageType.EXCEPTION:
3973 
      x = TApplicationException()
3974 
      x.read(self._iprot)
3975 
      self._iprot.readMessageEnd()
3976 
      raise x
4258 rajveer 3977 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3978 
    result.read(self._iprot)
3979 
    self._iprot.readMessageEnd()
3980 
    if result.ex is not None:
3981 
      raise result.ex
3982 
    return
3983 
 
4259 anupam.sin 3984 
  def refundTransaction(self, transactionId, refundedBy, reason):
3985 
    """
3986 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3987 
    need to be cancelled
4247 rajveer 3988 
 
4259 anupam.sin 3989 
    Parameters:
3990 
     - transactionId
3991 
     - refundedBy
3992 
     - reason
3993 
    """
3994 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3995 
    self.recv_refundTransaction()
3996 
 
3997 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3998 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3999 
    args = refundTransaction_args()
4000 
    args.transactionId = transactionId
4001 
    args.refundedBy = refundedBy
4002 
    args.reason = reason
4003 
    args.write(self._oprot)
4004 
    self._oprot.writeMessageEnd()
4005 
    self._oprot.trans.flush()
4006 
 
4007 
  def recv_refundTransaction(self, ):
4008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4009 
    if mtype == TMessageType.EXCEPTION:
4010 
      x = TApplicationException()
4011 
      x.read(self._iprot)
4012 
      self._iprot.readMessageEnd()
4013 
      raise x
4014 
    result = refundTransaction_result()
4015 
    result.read(self._iprot)
4016 
    self._iprot.readMessageEnd()
4017 
    if result.ex is not None:
4018 
      raise result.ex
4019 
    return
4020 
 
4324 mandeep.dh 4021 
  def updateShipmentAddress(self, orderId, addressId):
4022 
    """
4023 
    Updates shipment address of an order. Delivery and shipping date estimates
4024 
    etc. are also updated here.
4025 
 
4026 
    Throws TransactionServiceException in case address change is not
4027 
    possible due to certain reasons such as new pincode in address is
4028 
    not serviceable etc.
4029 
 
4030 
    Parameters:
4031 
     - orderId
4032 
     - addressId
4033 
    """
4034 
    self.send_updateShipmentAddress(orderId, addressId)
4035 
    self.recv_updateShipmentAddress()
4036 
 
4037 
  def send_updateShipmentAddress(self, orderId, addressId):
4038 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4039 
    args = updateShipmentAddress_args()
4040 
    args.orderId = orderId
4041 
    args.addressId = addressId
4042 
    args.write(self._oprot)
4043 
    self._oprot.writeMessageEnd()
4044 
    self._oprot.trans.flush()
4045 
 
4046 
  def recv_updateShipmentAddress(self, ):
4047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4048 
    if mtype == TMessageType.EXCEPTION:
4049 
      x = TApplicationException()
4050 
      x.read(self._iprot)
4051 
      self._iprot.readMessageEnd()
4052 
      raise x
4053 
    result = updateShipmentAddress_result()
4054 
    result.read(self._iprot)
4055 
    self._iprot.readMessageEnd()
4056 
    if result.ex is not None:
4057 
      raise result.ex
4058 
    return
4059 
 
4285 rajveer 4060 
  def acceptOrdersForItemId(self, itemId, inventory):
4061 
    """
4062 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4063 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4064 
 
4285 rajveer 4065 
    Parameters:
4066 
     - itemId
4067 
     - inventory
4068 
    """
4069 
    self.send_acceptOrdersForItemId(itemId, inventory)
4070 
    return self.recv_acceptOrdersForItemId()
4071 
 
4072 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4073 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4074 
    args = acceptOrdersForItemId_args()
4075 
    args.itemId = itemId
4076 
    args.inventory = inventory
4077 
    args.write(self._oprot)
4078 
    self._oprot.writeMessageEnd()
4079 
    self._oprot.trans.flush()
4080 
 
4081 
  def recv_acceptOrdersForItemId(self, ):
4082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4083 
    if mtype == TMessageType.EXCEPTION:
4084 
      x = TApplicationException()
4085 
      x.read(self._iprot)
4086 
      self._iprot.readMessageEnd()
4087 
      raise x
4088 
    result = acceptOrdersForItemId_result()
4089 
    result.read(self._iprot)
4090 
    self._iprot.readMessageEnd()
4091 
    if result.success is not None:
4092 
      return result.success
4093 
    if result.ex is not None:
4094 
      raise result.ex
4095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4096 
 
4369 rajveer 4097 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4098 
    """
4099 
    Parameters:
4100 
     - vendorId
4101 
     - itemId
4102 
     - quantity
4103 
     - estimate
4369 rajveer 4104 
     - isReminder
4303 rajveer 4105 
    """
4369 rajveer 4106 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4107 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4108 
 
4369 rajveer 4109 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4110 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4111 
    args = markOrdersAsPORaised_args()
4112 
    args.vendorId = vendorId
4113 
    args.itemId = itemId
4114 
    args.quantity = quantity
4115 
    args.estimate = estimate
4369 rajveer 4116 
    args.isReminder = isReminder
4303 rajveer 4117 
    args.write(self._oprot)
4118 
    self._oprot.writeMessageEnd()
4119 
    self._oprot.trans.flush()
4120 
 
4121 
  def recv_markOrdersAsPORaised(self, ):
4122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4123 
    if mtype == TMessageType.EXCEPTION:
4124 
      x = TApplicationException()
4125 
      x.read(self._iprot)
4126 
      self._iprot.readMessageEnd()
4127 
      raise x
4128 
    result = markOrdersAsPORaised_result()
4129 
    result.read(self._iprot)
4130 
    self._iprot.readMessageEnd()
4131 
    if result.ex is not None:
4132 
      raise result.ex
4133 
    return
4134 
 
4369 rajveer 4135 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4136 
    """
4137 
    Parameters:
4138 
     - vendorId
4139 
     - itemId
4140 
     - quantity
4141 
     - estimate
4369 rajveer 4142 
     - isReminder
4303 rajveer 4143 
    """
4369 rajveer 4144 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4145 
    self.recv_markOrdersAsReversalInitiated()
4146 
 
4369 rajveer 4147 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4148 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4149 
    args = markOrdersAsReversalInitiated_args()
4150 
    args.vendorId = vendorId
4151 
    args.itemId = itemId
4152 
    args.quantity = quantity
4153 
    args.estimate = estimate
4369 rajveer 4154 
    args.isReminder = isReminder
4303 rajveer 4155 
    args.write(self._oprot)
4156 
    self._oprot.writeMessageEnd()
4157 
    self._oprot.trans.flush()
4158 
 
4159 
  def recv_markOrdersAsReversalInitiated(self, ):
4160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4161 
    if mtype == TMessageType.EXCEPTION:
4162 
      x = TApplicationException()
4163 
      x.read(self._iprot)
4164 
      self._iprot.readMessageEnd()
4165 
      raise x
4166 
    result = markOrdersAsReversalInitiated_result()
4167 
    result.read(self._iprot)
4168 
    self._iprot.readMessageEnd()
4169 
    if result.ex is not None:
4170 
      raise result.ex
4171 
    return
4172 
 
4369 rajveer 4173 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4174 
    """
4175 
    Parameters:
4176 
     - vendorId
4177 
     - itemId
4178 
     - quantity
4179 
     - estimate
4369 rajveer 4180 
     - isReminder
4303 rajveer 4181 
    """
4369 rajveer 4182 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4183 
    self.recv_markOrdersAsNotAvailabke()
4184 
 
4369 rajveer 4185 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4186 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4187 
    args = markOrdersAsNotAvailabke_args()
4188 
    args.vendorId = vendorId
4189 
    args.itemId = itemId
4190 
    args.quantity = quantity
4191 
    args.estimate = estimate
4369 rajveer 4192 
    args.isReminder = isReminder
4303 rajveer 4193 
    args.write(self._oprot)
4194 
    self._oprot.writeMessageEnd()
4195 
    self._oprot.trans.flush()
4196 
 
4197 
  def recv_markOrdersAsNotAvailabke(self, ):
4198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4199 
    if mtype == TMessageType.EXCEPTION:
4200 
      x = TApplicationException()
4201 
      x.read(self._iprot)
4202 
      self._iprot.readMessageEnd()
4203 
      raise x
4204 
    result = markOrdersAsNotAvailabke_result()
4205 
    result.read(self._iprot)
4206 
    self._iprot.readMessageEnd()
4207 
    if result.ex is not None:
4208 
      raise result.ex
4209 
    return
4210 
 
4369 rajveer 4211 
  def markOrdersAsTimeout(self, vendorId):
4212 
    """
4213 
    Parameters:
4214 
     - vendorId
4215 
    """
4216 
    self.send_markOrdersAsTimeout(vendorId)
4217 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4218 
 
4369 rajveer 4219 
  def send_markOrdersAsTimeout(self, vendorId):
4220 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4221 
    args = markOrdersAsTimeout_args()
4222 
    args.vendorId = vendorId
4223 
    args.write(self._oprot)
4224 
    self._oprot.writeMessageEnd()
4225 
    self._oprot.trans.flush()
4226 
 
4227 
  def recv_markOrdersAsTimeout(self, ):
4228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4229 
    if mtype == TMessageType.EXCEPTION:
4230 
      x = TApplicationException()
4231 
      x.read(self._iprot)
4232 
      self._iprot.readMessageEnd()
4233 
      raise x
4234 
    result = markOrdersAsTimeout_result()
4235 
    result.read(self._iprot)
4236 
    self._iprot.readMessageEnd()
4237 
    if result.success is not None:
4238 
      return result.success
4239 
    if result.ex is not None:
4240 
      raise result.ex
4241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4242 
 
4662 rajveer 4243 
  def markOrderAsLostInTransit(self, orderId):
4244 
    """
4245 
    Mark order as LOST_IN_TRANSIT
4246 
 
4247 
    Parameters:
4248 
     - orderId
4249 
    """
4250 
    self.send_markOrderAsLostInTransit(orderId)
4251 
    return self.recv_markOrderAsLostInTransit()
4252 
 
4253 
  def send_markOrderAsLostInTransit(self, orderId):
4254 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4255 
    args = markOrderAsLostInTransit_args()
4256 
    args.orderId = orderId
4257 
    args.write(self._oprot)
4258 
    self._oprot.writeMessageEnd()
4259 
    self._oprot.trans.flush()
4260 
 
4261 
  def recv_markOrderAsLostInTransit(self, ):
4262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4263 
    if mtype == TMessageType.EXCEPTION:
4264 
      x = TApplicationException()
4265 
      x.read(self._iprot)
4266 
      self._iprot.readMessageEnd()
4267 
      raise x
4268 
    result = markOrderAsLostInTransit_result()
4269 
    result.read(self._iprot)
4270 
    self._iprot.readMessageEnd()
4271 
    if result.success is not None:
4272 
      return result.success
4273 
    if result.ex is not None:
4274 
      raise result.ex
4275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4276 
 
4386 anupam.sin 4277 
  def getOrderForAwb(self, awb):
4278 
    """
4279 
    Returns the order corresponding to an AWB number
4369 rajveer 4280 
 
4386 anupam.sin 4281 
    Parameters:
4282 
     - awb
4283 
    """
4284 
    self.send_getOrderForAwb(awb)
4285 
    return self.recv_getOrderForAwb()
4286 
 
4287 
  def send_getOrderForAwb(self, awb):
4288 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4289 
    args = getOrderForAwb_args()
4290 
    args.awb = awb
4291 
    args.write(self._oprot)
4292 
    self._oprot.writeMessageEnd()
4293 
    self._oprot.trans.flush()
4294 
 
4295 
  def recv_getOrderForAwb(self, ):
4296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4297 
    if mtype == TMessageType.EXCEPTION:
4298 
      x = TApplicationException()
4299 
      x.read(self._iprot)
4300 
      self._iprot.readMessageEnd()
4301 
      raise x
4302 
    result = getOrderForAwb_result()
4303 
    result.read(self._iprot)
4304 
    self._iprot.readMessageEnd()
4305 
    if result.success is not None:
4306 
      return result.success
4307 
    if result.ex is not None:
4308 
      raise result.ex
4309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4310 
 
4910 phani.kuma 4311 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4312 
    """
4910 phani.kuma 4313 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4314 
 
4506 phani.kuma 4315 
    Parameters:
4316 
     - logistics_provider_id
4910 phani.kuma 4317 
     - order_status_list
4506 phani.kuma 4318 
    """
4910 phani.kuma 4319 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4320 
    return self.recv_getOrdersForProviderForStatus()
4321 
 
4910 phani.kuma 4322 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4323 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4324 
    args = getOrdersForProviderForStatus_args()
4325 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4326 
    args.order_status_list = order_status_list
4506 phani.kuma 4327 
    args.write(self._oprot)
4328 
    self._oprot.writeMessageEnd()
4329 
    self._oprot.trans.flush()
4330 
 
4331 
  def recv_getOrdersForProviderForStatus(self, ):
4332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4333 
    if mtype == TMessageType.EXCEPTION:
4334 
      x = TApplicationException()
4335 
      x.read(self._iprot)
4336 
      self._iprot.readMessageEnd()
4337 
      raise x
4338 
    result = getOrdersForProviderForStatus_result()
4339 
    result.read(self._iprot)
4340 
    self._iprot.readMessageEnd()
4341 
    if result.success is not None:
4342 
      return result.success
4343 
    if result.ex is not None:
4344 
      raise result.ex
4345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4346 
 
4600 varun.gupt 4347 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4348 
    """
4349 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4350 
 
4600 varun.gupt 4351 
    Parameters:
4352 
     - vendorId
4353 
     - billingDateFrom
4354 
     - billingDateTo
4355 
    """
4356 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4357 
    return self.recv_getBilledOrdersForVendor()
4358 
 
4359 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4360 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4361 
    args = getBilledOrdersForVendor_args()
4362 
    args.vendorId = vendorId
4363 
    args.billingDateFrom = billingDateFrom
4364 
    args.billingDateTo = billingDateTo
4365 
    args.write(self._oprot)
4366 
    self._oprot.writeMessageEnd()
4367 
    self._oprot.trans.flush()
4368 
 
4369 
  def recv_getBilledOrdersForVendor(self, ):
4370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4371 
    if mtype == TMessageType.EXCEPTION:
4372 
      x = TApplicationException()
4373 
      x.read(self._iprot)
4374 
      self._iprot.readMessageEnd()
4375 
      raise x
4376 
    result = getBilledOrdersForVendor_result()
4377 
    result.read(self._iprot)
4378 
    self._iprot.readMessageEnd()
4379 
    if result.success is not None:
4380 
      return result.success
4381 
    if result.ex is not None:
4382 
      raise result.ex
4383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4384 
 
4607 rajveer 4385 
  def getSlippedSippingDateOrders(self, ):
4386 
    self.send_getSlippedSippingDateOrders()
4387 
    return self.recv_getSlippedSippingDateOrders()
4388 
 
4389 
  def send_getSlippedSippingDateOrders(self, ):
4390 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4391 
    args = getSlippedSippingDateOrders_args()
4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_getSlippedSippingDateOrders(self, ):
4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4403 
    result = getSlippedSippingDateOrders_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.success is not None:
4407 
      return result.success
4408 
    if result.ex is not None:
4409 
      raise result.ex
4410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4411 
 
4709 rajveer 4412 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4413 
    """
4414 
    Parameters:
4415 
     - cancelDateFrom
4416 
     - cancelDateTo
4417 
    """
4418 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4419 
    return self.recv_getCancelledOrders()
4420 
 
4421 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4422 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4423 
    args = getCancelledOrders_args()
4424 
    args.cancelDateFrom = cancelDateFrom
4425 
    args.cancelDateTo = cancelDateTo
4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_getCancelledOrders(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 = getCancelledOrders_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.success is not None:
4441 
      return result.success
4442 
    if result.ex is not None:
4443 
      raise result.ex
4444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4445 
 
4600 varun.gupt 4446 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4447 
    """
4448 
    Parameters:
4449 
     - mapAWBAndAmount
4450 
    """
4451 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4452 
    self.recv_saveBluedartSettlements()
4453 
 
4454 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4455 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4456 
    args = saveBluedartSettlements_args()
4457 
    args.mapAWBAndAmount = mapAWBAndAmount
4458 
    args.write(self._oprot)
4459 
    self._oprot.writeMessageEnd()
4460 
    self._oprot.trans.flush()
4461 
 
4462 
  def recv_saveBluedartSettlements(self, ):
4463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4464 
    if mtype == TMessageType.EXCEPTION:
4465 
      x = TApplicationException()
4466 
      x.read(self._iprot)
4467 
      self._iprot.readMessageEnd()
4468 
      raise x
4469 
    result = saveBluedartSettlements_result()
4470 
    result.read(self._iprot)
4471 
    self._iprot.readMessageEnd()
4472 
    if result.ex is not None:
4473 
      raise result.ex
4474 
    return
4475 
 
4905 varun.gupt 4476 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4477 
    """
4478 
    Parameters:
4479 
     - settlementDate
4480 
     - paymentGatewayId
4905 varun.gupt 4481 
     - referenceId
4600 varun.gupt 4482 
     - serviceTax
4483 
     - otherCharges
4484 
     - netCollection
4485 
    """
4905 varun.gupt 4486 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4487 
    self.recv_savePaymentSettlements()
4488 
 
4905 varun.gupt 4489 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4490 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4491 
    args = savePaymentSettlements_args()
4492 
    args.settlementDate = settlementDate
4493 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4494 
    args.referenceId = referenceId
4600 varun.gupt 4495 
    args.serviceTax = serviceTax
4496 
    args.otherCharges = otherCharges
4497 
    args.netCollection = netCollection
4498 
    args.write(self._oprot)
4499 
    self._oprot.writeMessageEnd()
4500 
    self._oprot.trans.flush()
4501 
 
4502 
  def recv_savePaymentSettlements(self, ):
4503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4504 
    if mtype == TMessageType.EXCEPTION:
4505 
      x = TApplicationException()
4506 
      x.read(self._iprot)
4507 
      self._iprot.readMessageEnd()
4508 
      raise x
4509 
    result = savePaymentSettlements_result()
4510 
    result.read(self._iprot)
4511 
    self._iprot.readMessageEnd()
4512 
    if result.ex is not None:
4513 
      raise result.ex
4514 
    return
4515 
 
4516 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4517 
    """
4518 
    Parameters:
4519 
     - settlementId
4520 
     - settlementDate
4521 
     - transactionDateFrom
4522 
     - transactionDateTo
4523 
     - amount
4524 
    """
4525 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4526 
    self.recv_saveEBSSettlementSummary()
4527 
 
4528 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4529 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4530 
    args = saveEBSSettlementSummary_args()
4531 
    args.settlementId = settlementId
4532 
    args.settlementDate = settlementDate
4533 
    args.transactionDateFrom = transactionDateFrom
4534 
    args.transactionDateTo = transactionDateTo
4535 
    args.amount = amount
4536 
    args.write(self._oprot)
4537 
    self._oprot.writeMessageEnd()
4538 
    self._oprot.trans.flush()
4539 
 
4540 
  def recv_saveEBSSettlementSummary(self, ):
4541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4542 
    if mtype == TMessageType.EXCEPTION:
4543 
      x = TApplicationException()
4544 
      x.read(self._iprot)
4545 
      self._iprot.readMessageEnd()
4546 
      raise x
4547 
    result = saveEBSSettlementSummary_result()
4548 
    result.read(self._iprot)
4549 
    self._iprot.readMessageEnd()
4550 
    if result.ex is not None:
4551 
      raise result.ex
4552 
    return
4553 
 
4554 
  def getSettlementForPaymentId(self, paymentId):
4555 
    """
4556 
    Parameters:
4557 
     - paymentId
4558 
    """
4559 
    self.send_getSettlementForPaymentId(paymentId)
4560 
    return self.recv_getSettlementForPaymentId()
4561 
 
4562 
  def send_getSettlementForPaymentId(self, paymentId):
4563 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4564 
    args = getSettlementForPaymentId_args()
4565 
    args.paymentId = paymentId
4566 
    args.write(self._oprot)
4567 
    self._oprot.writeMessageEnd()
4568 
    self._oprot.trans.flush()
4569 
 
4570 
  def recv_getSettlementForPaymentId(self, ):
4571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4572 
    if mtype == TMessageType.EXCEPTION:
4573 
      x = TApplicationException()
4574 
      x.read(self._iprot)
4575 
      self._iprot.readMessageEnd()
4576 
      raise x
4577 
    result = getSettlementForPaymentId_result()
4578 
    result.read(self._iprot)
4579 
    self._iprot.readMessageEnd()
4580 
    if result.success is not None:
4581 
      return result.success
4582 
    if result.ex is not None:
4583 
      raise result.ex
4584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4585 
 
4586 
  def getEBSSettlementSummaries(self, ):
4587 
    self.send_getEBSSettlementSummaries()
4588 
    return self.recv_getEBSSettlementSummaries()
4589 
 
4590 
  def send_getEBSSettlementSummaries(self, ):
4591 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4592 
    args = getEBSSettlementSummaries_args()
4593 
    args.write(self._oprot)
4594 
    self._oprot.writeMessageEnd()
4595 
    self._oprot.trans.flush()
4596 
 
4597 
  def recv_getEBSSettlementSummaries(self, ):
4598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4599 
    if mtype == TMessageType.EXCEPTION:
4600 
      x = TApplicationException()
4601 
      x.read(self._iprot)
4602 
      self._iprot.readMessageEnd()
4603 
      raise x
4604 
    result = getEBSSettlementSummaries_result()
4605 
    result.read(self._iprot)
4606 
    self._iprot.readMessageEnd()
4607 
    if result.success is not None:
4608 
      return result.success
4609 
    if result.ex is not None:
4610 
      raise result.ex
4611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4612 
 
4613 
  def markEBSSettlementUploaded(self, settlementId):
4614 
    """
4615 
    Parameters:
4616 
     - settlementId
4617 
    """
4618 
    self.send_markEBSSettlementUploaded(settlementId)
4619 
    self.recv_markEBSSettlementUploaded()
4620 
 
4621 
  def send_markEBSSettlementUploaded(self, settlementId):
4622 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4623 
    args = markEBSSettlementUploaded_args()
4624 
    args.settlementId = settlementId
4625 
    args.write(self._oprot)
4626 
    self._oprot.writeMessageEnd()
4627 
    self._oprot.trans.flush()
4628 
 
4629 
  def recv_markEBSSettlementUploaded(self, ):
4630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4631 
    if mtype == TMessageType.EXCEPTION:
4632 
      x = TApplicationException()
4633 
      x.read(self._iprot)
4634 
      self._iprot.readMessageEnd()
4635 
      raise x
4636 
    result = markEBSSettlementUploaded_result()
4637 
    result.read(self._iprot)
4638 
    self._iprot.readMessageEnd()
4639 
    if result.ex is not None:
4640 
      raise result.ex
4641 
    return
4642 
 
4643 
  def getEBSSettlementDate(self, settlementId):
4644 
    """
4645 
    Parameters:
4646 
     - settlementId
4647 
    """
4648 
    self.send_getEBSSettlementDate(settlementId)
4649 
    return self.recv_getEBSSettlementDate()
4650 
 
4651 
  def send_getEBSSettlementDate(self, settlementId):
4652 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4653 
    args = getEBSSettlementDate_args()
4654 
    args.settlementId = settlementId
4655 
    args.write(self._oprot)
4656 
    self._oprot.writeMessageEnd()
4657 
    self._oprot.trans.flush()
4658 
 
4659 
  def recv_getEBSSettlementDate(self, ):
4660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4661 
    if mtype == TMessageType.EXCEPTION:
4662 
      x = TApplicationException()
4663 
      x.read(self._iprot)
4664 
      self._iprot.readMessageEnd()
4665 
      raise x
4666 
    result = getEBSSettlementDate_result()
4667 
    result.read(self._iprot)
4668 
    self._iprot.readMessageEnd()
4669 
    if result.success is not None:
4670 
      return result.success
4671 
    if result.ex is not None:
4672 
      raise result.ex
4673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4674 
 
4715 varun.gupt 4675 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4676 
    """
4677 
    Parameters:
4678 
     - settlementDateFrom
4679 
     - settlementDateTo
4680 
     - isRefund
4681 
    """
4682 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4683 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4684 
 
4715 varun.gupt 4685 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4686 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4687 
    args = getSettlementsByDate_args()
4688 
    args.settlementDateFrom = settlementDateFrom
4689 
    args.settlementDateTo = settlementDateTo
4690 
    args.isRefund = isRefund
4691 
    args.write(self._oprot)
4692 
    self._oprot.writeMessageEnd()
4693 
    self._oprot.trans.flush()
4694 
 
4695 
  def recv_getSettlementsByDate(self, ):
4696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4697 
    if mtype == TMessageType.EXCEPTION:
4698 
      x = TApplicationException()
4699 
      x.read(self._iprot)
4700 
      self._iprot.readMessageEnd()
4701 
      raise x
4702 
    result = getSettlementsByDate_result()
4703 
    result.read(self._iprot)
4704 
    self._iprot.readMessageEnd()
4705 
    if result.success is not None:
4706 
      return result.success
4707 
    if result.ex is not None:
4708 
      raise result.ex
4709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4710 
 
4711 
  def getReshippedOrderIds(self, orderIds):
4712 
    """
4713 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4714 
 
4715 
    Parameters:
4716 
     - orderIds
4717 
    """
4718 
    self.send_getReshippedOrderIds(orderIds)
4719 
    return self.recv_getReshippedOrderIds()
4720 
 
4721 
  def send_getReshippedOrderIds(self, orderIds):
4722 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4723 
    args = getReshippedOrderIds_args()
4724 
    args.orderIds = orderIds
4725 
    args.write(self._oprot)
4726 
    self._oprot.writeMessageEnd()
4727 
    self._oprot.trans.flush()
4728 
 
4729 
  def recv_getReshippedOrderIds(self, ):
4730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4731 
    if mtype == TMessageType.EXCEPTION:
4732 
      x = TApplicationException()
4733 
      x.read(self._iprot)
4734 
      self._iprot.readMessageEnd()
4735 
      raise x
4736 
    result = getReshippedOrderIds_result()
4737 
    result.read(self._iprot)
4738 
    self._iprot.readMessageEnd()
4739 
    if result.success is not None:
4740 
      return result.success
4741 
    if result.ex is not None:
4742 
      raise result.ex
4743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4744 
 
4757 mandeep.dh 4745 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4746 
    """
4747 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4748 
    the quantities for which the PO is raised.
4715 varun.gupt 4749 
 
4757 mandeep.dh 4750 
    Parameters:
4751 
     - itemIdQuantityMap
4752 
     - purchaseOrderId
4753 
     - warehouseId
4754 
    """
4755 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4756 
    self.recv_updateOrdersAsPORaised()
4757 
 
4758 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4759 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4760 
    args = updateOrdersAsPORaised_args()
4761 
    args.itemIdQuantityMap = itemIdQuantityMap
4762 
    args.purchaseOrderId = purchaseOrderId
4763 
    args.warehouseId = warehouseId
4764 
    args.write(self._oprot)
4765 
    self._oprot.writeMessageEnd()
4766 
    self._oprot.trans.flush()
4767 
 
4768 
  def recv_updateOrdersAsPORaised(self, ):
4769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4770 
    if mtype == TMessageType.EXCEPTION:
4771 
      x = TApplicationException()
4772 
      x.read(self._iprot)
4773 
      self._iprot.readMessageEnd()
4774 
      raise x
4775 
    result = updateOrdersAsPORaised_result()
4776 
    result.read(self._iprot)
4777 
    self._iprot.readMessageEnd()
4778 
    if result.ex is not None:
4779 
      raise result.ex
4780 
    return
4781 
 
4875 varun.gupt 4782 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4783 
    """
4784 
    Parameters:
4785 
     - vendorId
4786 
    """
4787 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4788 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4789 
 
4875 varun.gupt 4790 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4791 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4792 
    args = getOrdersWhereVendorNotPaid_args()
4793 
    args.vendorId = vendorId
4794 
    args.write(self._oprot)
4795 
    self._oprot.writeMessageEnd()
4796 
    self._oprot.trans.flush()
4797 
 
4798 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4800 
    if mtype == TMessageType.EXCEPTION:
4801 
      x = TApplicationException()
4802 
      x.read(self._iprot)
4803 
      self._iprot.readMessageEnd()
4804 
      raise x
4805 
    result = getOrdersWhereVendorNotPaid_result()
4806 
    result.read(self._iprot)
4807 
    self._iprot.readMessageEnd()
4808 
    if result.success is not None:
4809 
      return result.success
4810 
    if result.ex is not None:
4811 
      raise result.ex
4812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4813 
 
4814 
 
3376 rajveer 4815 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4816 
  def __init__(self, handler):
3376 rajveer 4817 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4818 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4819 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4820 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4821 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4822 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4823 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4824 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4825 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4826 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4827 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4828 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4829 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4830 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4831 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4832 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4833 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4834 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4835 
    self._processMap["createOrder"] = Processor.process_createOrder
4836 
    self._processMap["getOrder"] = Processor.process_getOrder
4837 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4838 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4839 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4840 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4841 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4842 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4843 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4844 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4845 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4846 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4847 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4848 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4849 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4850 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4851 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 4852 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4853 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 4854 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 4855 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 4856 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
4857 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 4858 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 4859 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
4860 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
4861 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
4862 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
4863 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 4864 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4865 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4866 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4867 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4868 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4869 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4870 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4871 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4872 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4873 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4874 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 4875 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 4876 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 4877 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 4878 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4879 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4880 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4881 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4882 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4883 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4884 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4885 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4886 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4887 
    self._processMap["changeItem"] = Processor.process_changeItem
4888 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4889 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4890 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4891 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4892 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4893 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4894 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4895 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4896 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4897 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4898 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4899 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4900 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4901 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4902 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4903 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4904 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4905 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4906 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4907 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4908 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4909 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4910 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4911 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4912 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4913 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4914 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4915 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4916 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4917 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4918 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4919 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4920 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4921 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 4922 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
94 ashish 4923 
 
4924 
  def process(self, iprot, oprot):
4925 
    (name, type, seqid) = iprot.readMessageBegin()
4926 
    if name not in self._processMap:
4927 
      iprot.skip(TType.STRUCT)
4928 
      iprot.readMessageEnd()
4929 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4930 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4931 
      x.write(oprot)
4932 
      oprot.writeMessageEnd()
4933 
      oprot.trans.flush()
4934 
      return
4935 
    else:
4936 
      self._processMap[name](self, seqid, iprot, oprot)
4937 
    return True
4938 
 
4939 
  def process_createTransaction(self, seqid, iprot, oprot):
4940 
    args = createTransaction_args()
4941 
    args.read(iprot)
4942 
    iprot.readMessageEnd()
4943 
    result = createTransaction_result()
4944 
    try:
132 ashish 4945 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4946 
    except TransactionServiceException, ex:
4947 
      result.ex = ex
4948 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4949 
    result.write(oprot)
4950 
    oprot.writeMessageEnd()
4951 
    oprot.trans.flush()
4952 
 
4953 
  def process_getTransaction(self, seqid, iprot, oprot):
4954 
    args = getTransaction_args()
4955 
    args.read(iprot)
4956 
    iprot.readMessageEnd()
4957 
    result = getTransaction_result()
4958 
    try:
4959 
      result.success = self._handler.getTransaction(args.id)
4960 
    except TransactionServiceException, ex:
4961 
      result.ex = ex
4962 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4963 
    result.write(oprot)
4964 
    oprot.writeMessageEnd()
4965 
    oprot.trans.flush()
4966 
 
4967 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4968 
    args = getTransactionsForCustomer_args()
4969 
    args.read(iprot)
4970 
    iprot.readMessageEnd()
4971 
    result = getTransactionsForCustomer_result()
4972 
    try:
4973 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4974 
    except TransactionServiceException, ex:
4975 
      result.ex = ex
4976 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4977 
    result.write(oprot)
4978 
    oprot.writeMessageEnd()
4979 
    oprot.trans.flush()
4980 
 
132 ashish 4981 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4982 
    args = getTransactionsForShoppingCartId_args()
4983 
    args.read(iprot)
4984 
    iprot.readMessageEnd()
4985 
    result = getTransactionsForShoppingCartId_result()
4986 
    try:
4987 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4988 
    except TransactionServiceException, ex:
4989 
      result.ex = ex
4990 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4991 
    result.write(oprot)
4992 
    oprot.writeMessageEnd()
4993 
    oprot.trans.flush()
4994 
 
94 ashish 4995 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4996 
    args = getTransactionStatus_args()
4997 
    args.read(iprot)
4998 
    iprot.readMessageEnd()
4999 
    result = getTransactionStatus_result()
5000 
    try:
5001 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5002 
    except TransactionServiceException, ex:
5003 
      result.ex = ex
5004 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5005 
    result.write(oprot)
5006 
    oprot.writeMessageEnd()
5007 
    oprot.trans.flush()
5008 
 
5009 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5010 
    args = changeTransactionStatus_args()
5011 
    args.read(iprot)
5012 
    iprot.readMessageEnd()
5013 
    result = changeTransactionStatus_result()
5014 
    try:
5015 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5016 
    except TransactionServiceException, ex:
5017 
      result.ex = ex
5018 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5019 
    result.write(oprot)
5020 
    oprot.writeMessageEnd()
5021 
    oprot.trans.flush()
5022 
 
1398 varun.gupt 5023 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5024 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5025 
    args.read(iprot)
5026 
    iprot.readMessageEnd()
1398 varun.gupt 5027 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5028 
    try:
1398 varun.gupt 5029 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5030 
    except TransactionServiceException, ex:
5031 
      result.ex = ex
1398 varun.gupt 5032 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5033 
    result.write(oprot)
5034 
    oprot.writeMessageEnd()
5035 
    oprot.trans.flush()
5036 
 
483 rajveer 5037 
  def process_getAllOrders(self, seqid, iprot, oprot):
5038 
    args = getAllOrders_args()
94 ashish 5039 
    args.read(iprot)
5040 
    iprot.readMessageEnd()
483 rajveer 5041 
    result = getAllOrders_result()
94 ashish 5042 
    try:
4801 anupam.sin 5043 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5044 
    except TransactionServiceException, ex:
5045 
      result.ex = ex
483 rajveer 5046 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5047 
    result.write(oprot)
5048 
    oprot.writeMessageEnd()
5049 
    oprot.trans.flush()
5050 
 
4133 chandransh 5051 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5052 
    args = getOrdersInBatch_args()
5053 
    args.read(iprot)
5054 
    iprot.readMessageEnd()
5055 
    result = getOrdersInBatch_result()
5056 
    try:
5057 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5058 
    except TransactionServiceException, ex:
5059 
      result.ex = ex
5060 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5061 
    result.write(oprot)
5062 
    oprot.writeMessageEnd()
5063 
    oprot.trans.flush()
5064 
 
5065 
  def process_getOrderCount(self, seqid, iprot, oprot):
5066 
    args = getOrderCount_args()
5067 
    args.read(iprot)
5068 
    iprot.readMessageEnd()
5069 
    result = getOrderCount_result()
5070 
    try:
5071 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5072 
    except TransactionServiceException, ex:
5073 
      result.ex = ex
5074 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5075 
    result.write(oprot)
5076 
    oprot.writeMessageEnd()
5077 
    oprot.trans.flush()
5078 
 
999 varun.gupt 5079 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5080 
    args = getOrdersByBillingDate_args()
5081 
    args.read(iprot)
5082 
    iprot.readMessageEnd()
5083 
    result = getOrdersByBillingDate_result()
5084 
    try:
5085 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5086 
    except TransactionServiceException, ex:
5087 
      result.ex = ex
5088 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5089 
    result.write(oprot)
5090 
    oprot.writeMessageEnd()
5091 
    oprot.trans.flush()
5092 
 
3427 chandransh 5093 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5094 
    args = getOrdersByShippingDate_args()
5095 
    args.read(iprot)
5096 
    iprot.readMessageEnd()
5097 
    result = getOrdersByShippingDate_result()
5098 
    try:
3451 chandransh 5099 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5100 
    except TransactionServiceException, ex:
5101 
      result.ex = ex
5102 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5103 
    result.write(oprot)
5104 
    oprot.writeMessageEnd()
5105 
    oprot.trans.flush()
5106 
 
1382 varun.gupt 5107 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5108 
    args = getReturnableOrdersForCustomer_args()
5109 
    args.read(iprot)
5110 
    iprot.readMessageEnd()
5111 
    result = getReturnableOrdersForCustomer_result()
5112 
    try:
5113 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5114 
    except TransactionServiceException, ex:
5115 
      result.ex = ex
5116 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5117 
    result.write(oprot)
5118 
    oprot.writeMessageEnd()
5119 
    oprot.trans.flush()
5120 
 
5121 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5122 
    args = getCancellableOrdersForCustomer_args()
5123 
    args.read(iprot)
5124 
    iprot.readMessageEnd()
5125 
    result = getCancellableOrdersForCustomer_result()
5126 
    try:
5127 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5128 
    except TransactionServiceException, ex:
5129 
      result.ex = ex
5130 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5131 
    result.write(oprot)
5132 
    oprot.writeMessageEnd()
5133 
    oprot.trans.flush()
5134 
 
483 rajveer 5135 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5136 
    args = changeOrderStatus_args()
94 ashish 5137 
    args.read(iprot)
5138 
    iprot.readMessageEnd()
483 rajveer 5139 
    result = changeOrderStatus_result()
94 ashish 5140 
    try:
483 rajveer 5141 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5142 
    except TransactionServiceException, ex:
5143 
      result.ex = ex
483 rajveer 5144 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5145 
    result.write(oprot)
5146 
    oprot.writeMessageEnd()
5147 
    oprot.trans.flush()
5148 
 
483 rajveer 5149 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5150 
    args = getOrdersForTransaction_args()
94 ashish 5151 
    args.read(iprot)
5152 
    iprot.readMessageEnd()
483 rajveer 5153 
    result = getOrdersForTransaction_result()
94 ashish 5154 
    try:
1528 ankur.sing 5155 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5156 
    except TransactionServiceException, ex:
5157 
      result.ex = ex
483 rajveer 5158 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
5162 
 
483 rajveer 5163 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5164 
    args = getOrdersForCustomer_args()
94 ashish 5165 
    args.read(iprot)
5166 
    iprot.readMessageEnd()
483 rajveer 5167 
    result = getOrdersForCustomer_result()
94 ashish 5168 
    try:
3014 chandransh 5169 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5170 
    except TransactionServiceException, ex:
5171 
      result.ex = ex
483 rajveer 5172 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
5176 
 
483 rajveer 5177 
  def process_createOrder(self, seqid, iprot, oprot):
5178 
    args = createOrder_args()
94 ashish 5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
483 rajveer 5181 
    result = createOrder_result()
94 ashish 5182 
    try:
483 rajveer 5183 
      result.success = self._handler.createOrder(args.order)
94 ashish 5184 
    except TransactionServiceException, ex:
5185 
      result.ex = ex
483 rajveer 5186 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5187 
    result.write(oprot)
5188 
    oprot.writeMessageEnd()
5189 
    oprot.trans.flush()
5190 
 
483 rajveer 5191 
  def process_getOrder(self, seqid, iprot, oprot):
5192 
    args = getOrder_args()
94 ashish 5193 
    args.read(iprot)
5194 
    iprot.readMessageEnd()
483 rajveer 5195 
    result = getOrder_result()
94 ashish 5196 
    try:
483 rajveer 5197 
      result.success = self._handler.getOrder(args.id)
94 ashish 5198 
    except TransactionServiceException, ex:
5199 
      result.ex = ex
483 rajveer 5200 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
5204 
 
483 rajveer 5205 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5206 
    args = getLineItemsForOrder_args()
94 ashish 5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
483 rajveer 5209 
    result = getLineItemsForOrder_result()
94 ashish 5210 
    try:
483 rajveer 5211 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5212 
    except TransactionServiceException, ex:
5213 
      result.ex = ex
483 rajveer 5214 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5215 
    result.write(oprot)
5216 
    oprot.writeMessageEnd()
5217 
    oprot.trans.flush()
5218 
 
1528 ankur.sing 5219 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5220 
    args = getOrderForCustomer_args()
5221 
    args.read(iprot)
5222 
    iprot.readMessageEnd()
5223 
    result = getOrderForCustomer_result()
5224 
    try:
5225 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5226 
    except TransactionServiceException, ex:
5227 
      result.ex = ex
5228 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5229 
    result.write(oprot)
5230 
    oprot.writeMessageEnd()
5231 
    oprot.trans.flush()
5232 
 
3064 chandransh 5233 
  def process_getAlerts(self, seqid, iprot, oprot):
5234 
    args = getAlerts_args()
5235 
    args.read(iprot)
5236 
    iprot.readMessageEnd()
5237 
    result = getAlerts_result()
4444 rajveer 5238 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5239 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5240 
    result.write(oprot)
5241 
    oprot.writeMessageEnd()
5242 
    oprot.trans.flush()
5243 
 
4394 rajveer 5244 
  def process_addAlert(self, seqid, iprot, oprot):
5245 
    args = addAlert_args()
3064 chandransh 5246 
    args.read(iprot)
5247 
    iprot.readMessageEnd()
4394 rajveer 5248 
    result = addAlert_result()
4444 rajveer 5249 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5250 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5251 
    result.write(oprot)
5252 
    oprot.writeMessageEnd()
5253 
    oprot.trans.flush()
5254 
 
4444 rajveer 5255 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5256 
    args = markAlertsAsSeen_args()
5257 
    args.read(iprot)
5258 
    iprot.readMessageEnd()
5259 
    result = markAlertsAsSeen_result()
5260 
    self._handler.markAlertsAsSeen(args.warehouseId)
5261 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5262 
    result.write(oprot)
5263 
    oprot.writeMessageEnd()
5264 
    oprot.trans.flush()
5265 
 
3064 chandransh 5266 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5267 
    args = getValidOrderCount_args()
5268 
    args.read(iprot)
5269 
    iprot.readMessageEnd()
5270 
    result = getValidOrderCount_result()
5271 
    result.success = self._handler.getValidOrderCount()
5272 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5273 
    result.write(oprot)
5274 
    oprot.writeMessageEnd()
5275 
    oprot.trans.flush()
5276 
 
5277 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5278 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5279 
    args.read(iprot)
5280 
    iprot.readMessageEnd()
5281 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5282 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5283 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5284 
    result.write(oprot)
5285 
    oprot.writeMessageEnd()
5286 
    oprot.trans.flush()
5287 
 
5288 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5289 
    args = getValidOrdersAmountRange_args()
5290 
    args.read(iprot)
5291 
    iprot.readMessageEnd()
5292 
    result = getValidOrdersAmountRange_result()
5293 
    result.success = self._handler.getValidOrdersAmountRange()
5294 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5295 
    result.write(oprot)
5296 
    oprot.writeMessageEnd()
5297 
    oprot.trans.flush()
5298 
 
5299 
  def process_getValidOrders(self, seqid, iprot, oprot):
5300 
    args = getValidOrders_args()
5301 
    args.read(iprot)
5302 
    iprot.readMessageEnd()
5303 
    result = getValidOrders_result()
5304 
    result.success = self._handler.getValidOrders(args.limit)
5305 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5306 
    result.write(oprot)
5307 
    oprot.writeMessageEnd()
5308 
    oprot.trans.flush()
5309 
 
1220 chandransh 5310 
  def process_batchOrders(self, seqid, iprot, oprot):
5311 
    args = batchOrders_args()
5312 
    args.read(iprot)
5313 
    iprot.readMessageEnd()
5314 
    result = batchOrders_result()
5315 
    try:
5316 
      result.success = self._handler.batchOrders(args.warehouseId)
5317 
    except TransactionServiceException, ex:
5318 
      result.ex = ex
5319 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5320 
    result.write(oprot)
5321 
    oprot.writeMessageEnd()
5322 
    oprot.trans.flush()
5323 
 
1208 chandransh 5324 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5325 
    args = markOrderAsOutOfStock_args()
5326 
    args.read(iprot)
5327 
    iprot.readMessageEnd()
5328 
    result = markOrderAsOutOfStock_result()
5329 
    try:
5330 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5331 
    except TransactionServiceException, ex:
5332 
      result.ex = ex
5333 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5334 
    result.write(oprot)
5335 
    oprot.writeMessageEnd()
5336 
    oprot.trans.flush()
5337 
 
3064 chandransh 5338 
  def process_verifyOrder(self, seqid, iprot, oprot):
5339 
    args = verifyOrder_args()
759 chandransh 5340 
    args.read(iprot)
5341 
    iprot.readMessageEnd()
3064 chandransh 5342 
    result = verifyOrder_result()
759 chandransh 5343 
    try:
3064 chandransh 5344 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5345 
    except TransactionServiceException, ex:
5346 
      result.ex = ex
3064 chandransh 5347 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5348 
    result.write(oprot)
5349 
    oprot.writeMessageEnd()
5350 
    oprot.trans.flush()
5351 
 
3064 chandransh 5352 
  def process_acceptOrder(self, seqid, iprot, oprot):
5353 
    args = acceptOrder_args()
1113 chandransh 5354 
    args.read(iprot)
5355 
    iprot.readMessageEnd()
3064 chandransh 5356 
    result = acceptOrder_result()
1113 chandransh 5357 
    try:
3064 chandransh 5358 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5359 
    except TransactionServiceException, ex:
5360 
      result.ex = ex
3064 chandransh 5361 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5362 
    result.write(oprot)
5363 
    oprot.writeMessageEnd()
5364 
    oprot.trans.flush()
5365 
 
3064 chandransh 5366 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5367 
    args = addBillingDetails_args()
1135 chandransh 5368 
    args.read(iprot)
5369 
    iprot.readMessageEnd()
3064 chandransh 5370 
    result = addBillingDetails_result()
1135 chandransh 5371 
    try:
4763 rajveer 5372 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId, args.authorize)
1135 chandransh 5373 
    except TransactionServiceException, ex:
5374 
      result.ex = ex
3064 chandransh 5375 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5376 
    result.write(oprot)
5377 
    oprot.writeMessageEnd()
5378 
    oprot.trans.flush()
5379 
 
4579 rajveer 5380 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5381 
    args = addInvoiceNumber_args()
5382 
    args.read(iprot)
5383 
    iprot.readMessageEnd()
5384 
    result = addInvoiceNumber_result()
5385 
    try:
4763 rajveer 5386 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5387 
    except TransactionServiceException, ex:
5388 
      result.ex = ex
5389 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5390 
    result.write(oprot)
5391 
    oprot.writeMessageEnd()
5392 
    oprot.trans.flush()
5393 
 
4410 rajveer 5394 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5395 
    args = markOrdersAsShippedFromWarehouse_args()
5396 
    args.read(iprot)
5397 
    iprot.readMessageEnd()
5398 
    result = markOrdersAsShippedFromWarehouse_result()
5399 
    try:
4789 rajveer 5400 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5401 
    except TransactionServiceException, ex:
5402 
      result.ex = ex
5403 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5404 
    result.write(oprot)
5405 
    oprot.writeMessageEnd()
5406 
    oprot.trans.flush()
5407 
 
3064 chandransh 5408 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5409 
    args = markOrdersAsPickedUp_args()
304 ashish 5410 
    args.read(iprot)
5411 
    iprot.readMessageEnd()
3064 chandransh 5412 
    result = markOrdersAsPickedUp_result()
5413 
    try:
4910 phani.kuma 5414 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5415 
    except TransactionServiceException, ex:
5416 
      result.ex = ex
5417 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5418 
    result.write(oprot)
5419 
    oprot.writeMessageEnd()
5420 
    oprot.trans.flush()
94 ashish 5421 
 
4910 phani.kuma 5422 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5423 
    args = getOrdersNotPickedUp_args()
5424 
    args.read(iprot)
5425 
    iprot.readMessageEnd()
5426 
    result = getOrdersNotPickedUp_result()
5427 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5428 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5429 
    result.write(oprot)
5430 
    oprot.writeMessageEnd()
5431 
    oprot.trans.flush()
5432 
 
3064 chandransh 5433 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5434 
    args = markOrdersAsDelivered_args()
304 ashish 5435 
    args.read(iprot)
5436 
    iprot.readMessageEnd()
3064 chandransh 5437 
    result = markOrdersAsDelivered_result()
5438 
    try:
5439 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5440 
    except TransactionServiceException, ex:
5441 
      result.ex = ex
5442 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5443 
    result.write(oprot)
5444 
    oprot.writeMessageEnd()
5445 
    oprot.trans.flush()
5446 
 
4910 phani.kuma 5447 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5448 
    args = markAsRTOrders_args()
1596 ankur.sing 5449 
    args.read(iprot)
5450 
    iprot.readMessageEnd()
4910 phani.kuma 5451 
    result = markAsRTOrders_result()
3064 chandransh 5452 
    try:
4910 phani.kuma 5453 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5454 
    except TransactionServiceException, ex:
5455 
      result.ex = ex
4910 phani.kuma 5456 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5457 
    result.write(oprot)
5458 
    oprot.writeMessageEnd()
5459 
    oprot.trans.flush()
304 ashish 5460 
 
4910 phani.kuma 5461 
  def process_getRTOrders(self, seqid, iprot, oprot):
5462 
    args = getRTOrders_args()
5463 
    args.read(iprot)
5464 
    iprot.readMessageEnd()
5465 
    result = getRTOrders_result()
5466 
    result.success = self._handler.getRTOrders(args.providerId)
5467 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5468 
    result.write(oprot)
5469 
    oprot.writeMessageEnd()
5470 
    oprot.trans.flush()
5471 
 
3064 chandransh 5472 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5473 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5474 
    args.read(iprot)
5475 
    iprot.readMessageEnd()
3064 chandransh 5476 
    result = updateNonDeliveryReason_result()
5477 
    try:
4910 phani.kuma 5478 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5479 
    except TransactionServiceException, ex:
5480 
      result.ex = ex
5481 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5482 
    result.write(oprot)
5483 
    oprot.writeMessageEnd()
5484 
    oprot.trans.flush()
1596 ankur.sing 5485 
 
4910 phani.kuma 5486 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5487 
    args = getNonDeliveredOrdersbyCourier_args()
5488 
    args.read(iprot)
5489 
    iprot.readMessageEnd()
5490 
    result = getNonDeliveredOrdersbyCourier_result()
5491 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5492 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5493 
    result.write(oprot)
5494 
    oprot.writeMessageEnd()
5495 
    oprot.trans.flush()
5496 
 
5497 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5498 
    args = markOrdersAsLocalConnected_args()
5499 
    args.read(iprot)
5500 
    iprot.readMessageEnd()
5501 
    result = markOrdersAsLocalConnected_result()
5502 
    try:
5503 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5504 
    except TransactionServiceException, ex:
5505 
      result.ex = ex
5506 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5507 
    result.write(oprot)
5508 
    oprot.writeMessageEnd()
5509 
    oprot.trans.flush()
5510 
 
5511 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5512 
    args = getOrdersNotLocalConnected_args()
5513 
    args.read(iprot)
5514 
    iprot.readMessageEnd()
5515 
    result = getOrdersNotLocalConnected_result()
5516 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5517 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5518 
    result.write(oprot)
5519 
    oprot.writeMessageEnd()
5520 
    oprot.trans.flush()
5521 
 
5522 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5523 
    args = markOrdersAsDestinationCityReached_args()
5524 
    args.read(iprot)
5525 
    iprot.readMessageEnd()
5526 
    result = markOrdersAsDestinationCityReached_result()
5527 
    try:
5528 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5529 
    except TransactionServiceException, ex:
5530 
      result.ex = ex
5531 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5532 
    result.write(oprot)
5533 
    oprot.writeMessageEnd()
5534 
    oprot.trans.flush()
5535 
 
5536 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5537 
    args = markOrdersAsFirstDeliveryAttempted_args()
5538 
    args.read(iprot)
5539 
    iprot.readMessageEnd()
5540 
    result = markOrdersAsFirstDeliveryAttempted_result()
5541 
    try:
5542 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5543 
    except TransactionServiceException, ex:
5544 
      result.ex = ex
5545 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5546 
    result.write(oprot)
5547 
    oprot.writeMessageEnd()
5548 
    oprot.trans.flush()
5549 
 
3064 chandransh 5550 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5551 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5552 
    args.read(iprot)
5553 
    iprot.readMessageEnd()
3064 chandransh 5554 
    result = getUndeliveredOrders_result()
5555 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5556 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5557 
    result.write(oprot)
5558 
    oprot.writeMessageEnd()
5559 
    oprot.trans.flush()
5560 
 
4783 phani.kuma 5561 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5562 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5563 
    args.read(iprot)
5564 
    iprot.readMessageEnd()
5565 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5566 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5567 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5568 
    result.write(oprot)
5569 
    oprot.writeMessageEnd()
5570 
    oprot.trans.flush()
5571 
 
2536 chandransh 5572 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5573 
    args = toggleDOAFlag_args()
5574 
    args.read(iprot)
5575 
    iprot.readMessageEnd()
5576 
    result = toggleDOAFlag_result()
5577 
    try:
5578 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5579 
    except TransactionServiceException, ex:
5580 
      result.ex = ex
5581 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5582 
    result.write(oprot)
5583 
    oprot.writeMessageEnd()
5584 
    oprot.trans.flush()
1886 ankur.sing 5585 
 
4712 rajveer 5586 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5587 
    args = markOrderAsDelivered_args()
5588 
    args.read(iprot)
5589 
    iprot.readMessageEnd()
5590 
    result = markOrderAsDelivered_result()
5591 
    try:
5592 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5593 
    except TransactionServiceException, ex:
5594 
      result.ex = ex
5595 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5596 
    result.write(oprot)
5597 
    oprot.writeMessageEnd()
5598 
    oprot.trans.flush()
5599 
 
4454 rajveer 5600 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5601 
    args = markOrderDoaRequestReceived_args()
5602 
    args.read(iprot)
5603 
    iprot.readMessageEnd()
5604 
    result = markOrderDoaRequestReceived_result()
5605 
    try:
5606 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5607 
    except TransactionServiceException, ex:
5608 
      result.ex = ex
5609 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
5614 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5615 
    args = markOrderDoaRequestAuthorized_args()
5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
5618 
    result = markOrderDoaRequestAuthorized_result()
5619 
    try:
5620 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5621 
    except TransactionServiceException, ex:
5622 
      result.ex = ex
5623 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5624 
    result.write(oprot)
5625 
    oprot.writeMessageEnd()
5626 
    oprot.trans.flush()
5627 
 
4488 rajveer 5628 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5629 
    args = markOrderReturnRequestReceived_args()
5630 
    args.read(iprot)
5631 
    iprot.readMessageEnd()
5632 
    result = markOrderReturnRequestReceived_result()
5633 
    try:
5634 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5635 
    except TransactionServiceException, ex:
5636 
      result.ex = ex
5637 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5638 
    result.write(oprot)
5639 
    oprot.writeMessageEnd()
5640 
    oprot.trans.flush()
5641 
 
5642 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5643 
    args = markOrderReturnRequestAuthorized_args()
5644 
    args.read(iprot)
5645 
    iprot.readMessageEnd()
5646 
    result = markOrderReturnRequestAuthorized_result()
5647 
    try:
5648 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5649 
    except TransactionServiceException, ex:
5650 
      result.ex = ex
5651 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5652 
    result.write(oprot)
5653 
    oprot.writeMessageEnd()
5654 
    oprot.trans.flush()
5655 
 
2536 chandransh 5656 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5657 
    args = requestPickupNumber_args()
5658 
    args.read(iprot)
5659 
    iprot.readMessageEnd()
5660 
    result = requestPickupNumber_result()
5661 
    try:
4579 rajveer 5662 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5663 
    except TransactionServiceException, ex:
5664 
      result.ex = ex
5665 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5666 
    result.write(oprot)
5667 
    oprot.writeMessageEnd()
5668 
    oprot.trans.flush()
5669 
 
5670 
  def process_authorizePickup(self, seqid, iprot, oprot):
5671 
    args = authorizePickup_args()
5672 
    args.read(iprot)
5673 
    iprot.readMessageEnd()
5674 
    result = authorizePickup_result()
5675 
    try:
4602 rajveer 5676 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5677 
    except TransactionServiceException, ex:
5678 
      result.ex = ex
5679 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5680 
    result.write(oprot)
5681 
    oprot.writeMessageEnd()
5682 
    oprot.trans.flush()
5683 
 
2764 chandransh 5684 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5685 
    args = markDoasAsPickedUp_args()
5686 
    args.read(iprot)
5687 
    iprot.readMessageEnd()
5688 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5689 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5690 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5691 
    result.write(oprot)
5692 
    oprot.writeMessageEnd()
5693 
    oprot.trans.flush()
5694 
 
4910 phani.kuma 5695 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5696 
    args = getDoasNotPickedUp_args()
5697 
    args.read(iprot)
5698 
    iprot.readMessageEnd()
5699 
    result = getDoasNotPickedUp_result()
5700 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5701 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5702 
    result.write(oprot)
5703 
    oprot.writeMessageEnd()
5704 
    oprot.trans.flush()
5705 
 
4741 phani.kuma 5706 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5707 
    args = markReturnOrdersAsPickedUp_args()
5708 
    args.read(iprot)
5709 
    iprot.readMessageEnd()
5710 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5711 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5712 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5713 
    result.write(oprot)
5714 
    oprot.writeMessageEnd()
5715 
    oprot.trans.flush()
5716 
 
4910 phani.kuma 5717 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5718 
    args = getReturnOrdersNotPickedUp_args()
5719 
    args.read(iprot)
5720 
    iprot.readMessageEnd()
5721 
    result = getReturnOrdersNotPickedUp_result()
5722 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5723 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5724 
    result.write(oprot)
5725 
    oprot.writeMessageEnd()
5726 
    oprot.trans.flush()
5727 
 
2616 chandransh 5728 
  def process_receiveReturn(self, seqid, iprot, oprot):
5729 
    args = receiveReturn_args()
2591 chandransh 5730 
    args.read(iprot)
5731 
    iprot.readMessageEnd()
2616 chandransh 5732 
    result = receiveReturn_result()
2591 chandransh 5733 
    try:
4479 rajveer 5734 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5735 
    except TransactionServiceException, ex:
5736 
      result.ex = ex
2616 chandransh 5737 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5738 
    result.write(oprot)
5739 
    oprot.writeMessageEnd()
5740 
    oprot.trans.flush()
2536 chandransh 5741 
 
2591 chandransh 5742 
  def process_validateDoa(self, seqid, iprot, oprot):
5743 
    args = validateDoa_args()
5744 
    args.read(iprot)
5745 
    iprot.readMessageEnd()
5746 
    result = validateDoa_result()
5747 
    try:
5748 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5749 
    except TransactionServiceException, ex:
5750 
      result.ex = ex
5751 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5752 
    result.write(oprot)
5753 
    oprot.writeMessageEnd()
5754 
    oprot.trans.flush()
5755 
 
4495 rajveer 5756 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5757 
    args = validateReturnProduct_args()
5758 
    args.read(iprot)
5759 
    iprot.readMessageEnd()
5760 
    result = validateReturnProduct_result()
5761 
    try:
5762 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5763 
    except TransactionServiceException, ex:
5764 
      result.ex = ex
5765 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5766 
    result.write(oprot)
5767 
    oprot.writeMessageEnd()
5768 
    oprot.trans.flush()
5769 
 
2616 chandransh 5770 
  def process_reshipOrder(self, seqid, iprot, oprot):
5771 
    args = reshipOrder_args()
5772 
    args.read(iprot)
5773 
    iprot.readMessageEnd()
5774 
    result = reshipOrder_result()
5775 
    try:
5776 
      result.success = self._handler.reshipOrder(args.orderId)
5777 
    except TransactionServiceException, ex:
5778 
      result.ex = ex
5779 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5780 
    result.write(oprot)
5781 
    oprot.writeMessageEnd()
5782 
    oprot.trans.flush()
2591 chandransh 5783 
 
2616 chandransh 5784 
  def process_refundOrder(self, seqid, iprot, oprot):
5785 
    args = refundOrder_args()
5786 
    args.read(iprot)
5787 
    iprot.readMessageEnd()
5788 
    result = refundOrder_result()
5789 
    try:
3226 chandransh 5790 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5791 
    except TransactionServiceException, ex:
5792 
      result.ex = ex
5793 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5794 
    result.write(oprot)
5795 
    oprot.writeMessageEnd()
5796 
    oprot.trans.flush()
5797 
 
2690 chandransh 5798 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5799 
    args = getReturnOrders_args()
5800 
    args.read(iprot)
5801 
    iprot.readMessageEnd()
5802 
    result = getReturnOrders_result()
5803 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5804 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5805 
    result.write(oprot)
5806 
    oprot.writeMessageEnd()
5807 
    oprot.trans.flush()
2616 chandransh 5808 
 
2700 chandransh 5809 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5810 
    args = getReturnOrder_args()
5811 
    args.read(iprot)
5812 
    iprot.readMessageEnd()
5813 
    result = getReturnOrder_result()
5814 
    try:
5815 
      result.success = self._handler.getReturnOrder(args.id)
5816 
    except TransactionServiceException, ex:
5817 
      result.ex = ex
5818 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
5822 
 
2690 chandransh 5823 
  def process_processReturn(self, seqid, iprot, oprot):
5824 
    args = processReturn_args()
5825 
    args.read(iprot)
5826 
    iprot.readMessageEnd()
5827 
    result = processReturn_result()
5828 
    try:
5829 
      self._handler.processReturn(args.returnOrderId)
5830 
    except TransactionServiceException, ex:
5831 
      result.ex = ex
5832 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5833 
    result.write(oprot)
5834 
    oprot.writeMessageEnd()
5835 
    oprot.trans.flush()
5836 
 
3451 chandransh 5837 
  def process_updateWeight(self, seqid, iprot, oprot):
5838 
    args = updateWeight_args()
5839 
    args.read(iprot)
5840 
    iprot.readMessageEnd()
5841 
    result = updateWeight_result()
5842 
    try:
5843 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5844 
    except TransactionServiceException, ex:
5845 
      result.ex = ex
5846 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5847 
    result.write(oprot)
5848 
    oprot.writeMessageEnd()
5849 
    oprot.trans.flush()
2819 chandransh 5850 
 
3469 chandransh 5851 
  def process_changeItem(self, seqid, iprot, oprot):
5852 
    args = changeItem_args()
5853 
    args.read(iprot)
5854 
    iprot.readMessageEnd()
5855 
    result = changeItem_result()
5856 
    try:
5857 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5858 
    except TransactionServiceException, ex:
5859 
      result.ex = ex
5860 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5861 
    result.write(oprot)
5862 
    oprot.writeMessageEnd()
5863 
    oprot.trans.flush()
3451 chandransh 5864 
 
3469 chandransh 5865 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5866 
    args = shiftToWarehouse_args()
5867 
    args.read(iprot)
5868 
    iprot.readMessageEnd()
5869 
    result = shiftToWarehouse_result()
5870 
    try:
5871 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5872 
    except TransactionServiceException, ex:
5873 
      result.ex = ex
5874 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5875 
    result.write(oprot)
5876 
    oprot.writeMessageEnd()
5877 
    oprot.trans.flush()
5878 
 
3553 chandransh 5879 
  def process_addDelayReason(self, seqid, iprot, oprot):
5880 
    args = addDelayReason_args()
5881 
    args.read(iprot)
5882 
    iprot.readMessageEnd()
5883 
    result = addDelayReason_result()
5884 
    try:
4647 rajveer 5885 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5886 
    except TransactionServiceException, ex:
5887 
      result.ex = ex
5888 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5889 
    result.write(oprot)
5890 
    oprot.writeMessageEnd()
5891 
    oprot.trans.flush()
3469 chandransh 5892 
 
3956 chandransh 5893 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5894 
    args = reconcileCodCollection_args()
5895 
    args.read(iprot)
5896 
    iprot.readMessageEnd()
5897 
    result = reconcileCodCollection_result()
5898 
    try:
5899 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5900 
    except TransactionServiceException, ex:
5901 
      result.ex = ex
5902 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5903 
    result.write(oprot)
5904 
    oprot.writeMessageEnd()
5905 
    oprot.trans.flush()
3553 chandransh 5906 
 
4008 mandeep.dh 5907 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5908 
    args = getTransactionsRequiringExtraProcessing_args()
5909 
    args.read(iprot)
5910 
    iprot.readMessageEnd()
5911 
    result = getTransactionsRequiringExtraProcessing_result()
5912 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5913 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5914 
    result.write(oprot)
5915 
    oprot.writeMessageEnd()
5916 
    oprot.trans.flush()
3956 chandransh 5917 
 
4008 mandeep.dh 5918 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5919 
    args = markTransactionAsProcessed_args()
5920 
    args.read(iprot)
5921 
    iprot.readMessageEnd()
5922 
    result = markTransactionAsProcessed_result()
5923 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5924 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5925 
    result.write(oprot)
5926 
    oprot.writeMessageEnd()
5927 
    oprot.trans.flush()
5928 
 
4018 chandransh 5929 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5930 
    args = getItemWiseRiskyOrdersCount_args()
5931 
    args.read(iprot)
5932 
    iprot.readMessageEnd()
5933 
    result = getItemWiseRiskyOrdersCount_result()
5934 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5935 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5936 
    result.write(oprot)
5937 
    oprot.writeMessageEnd()
5938 
    oprot.trans.flush()
4008 mandeep.dh 5939 
 
4295 varun.gupt 5940 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5941 
    args = getOrdersForItemIds_args()
5942 
    args.read(iprot)
5943 
    iprot.readMessageEnd()
5944 
    result = getOrdersForItemIds_result()
5945 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5946 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5947 
    result.write(oprot)
5948 
    oprot.writeMessageEnd()
5949 
    oprot.trans.flush()
5950 
 
4247 rajveer 5951 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5952 
    args = markOrderCancellationRequestReceived_args()
5953 
    args.read(iprot)
5954 
    iprot.readMessageEnd()
5955 
    result = markOrderCancellationRequestReceived_result()
5956 
    try:
5957 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5958 
    except TransactionServiceException, ex:
5959 
      result.ex = ex
5960 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5961 
    result.write(oprot)
5962 
    oprot.writeMessageEnd()
5963 
    oprot.trans.flush()
4018 chandransh 5964 
 
4247 rajveer 5965 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5966 
    args = markOrderCancellationRequestConfirmed_args()
5967 
    args.read(iprot)
5968 
    iprot.readMessageEnd()
5969 
    result = markOrderCancellationRequestConfirmed_result()
5970 
    try:
5971 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5972 
    except TransactionServiceException, ex:
5973 
      result.ex = ex
5974 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5975 
    result.write(oprot)
5976 
    oprot.writeMessageEnd()
5977 
    oprot.trans.flush()
5978 
 
5979 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5980 
    args = markOrderCancellationRequestDenied_args()
5981 
    args.read(iprot)
5982 
    iprot.readMessageEnd()
5983 
    result = markOrderCancellationRequestDenied_result()
5984 
    try:
5985 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5986 
    except TransactionServiceException, ex:
5987 
      result.ex = ex
5988 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5989 
    result.write(oprot)
5990 
    oprot.writeMessageEnd()
5991 
    oprot.trans.flush()
5992 
 
4258 rajveer 5993 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5994 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5995 
    args.read(iprot)
5996 
    iprot.readMessageEnd()
4258 rajveer 5997 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5998 
    try:
4258 rajveer 5999 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6000 
    except TransactionServiceException, ex:
6001 
      result.ex = ex
4258 rajveer 6002 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6003 
    result.write(oprot)
6004 
    oprot.writeMessageEnd()
6005 
    oprot.trans.flush()
6006 
 
4259 anupam.sin 6007 
  def process_refundTransaction(self, seqid, iprot, oprot):
6008 
    args = refundTransaction_args()
6009 
    args.read(iprot)
6010 
    iprot.readMessageEnd()
6011 
    result = refundTransaction_result()
6012 
    try:
6013 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6014 
    except TransactionServiceException, ex:
6015 
      result.ex = ex
6016 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6017 
    result.write(oprot)
6018 
    oprot.writeMessageEnd()
6019 
    oprot.trans.flush()
4247 rajveer 6020 
 
4324 mandeep.dh 6021 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6022 
    args = updateShipmentAddress_args()
6023 
    args.read(iprot)
6024 
    iprot.readMessageEnd()
6025 
    result = updateShipmentAddress_result()
6026 
    try:
6027 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6028 
    except TransactionServiceException, ex:
6029 
      result.ex = ex
6030 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6031 
    result.write(oprot)
6032 
    oprot.writeMessageEnd()
6033 
    oprot.trans.flush()
6034 
 
4285 rajveer 6035 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6036 
    args = acceptOrdersForItemId_args()
6037 
    args.read(iprot)
6038 
    iprot.readMessageEnd()
6039 
    result = acceptOrdersForItemId_result()
6040 
    try:
6041 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6042 
    except TransactionServiceException, ex:
6043 
      result.ex = ex
6044 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6045 
    result.write(oprot)
6046 
    oprot.writeMessageEnd()
6047 
    oprot.trans.flush()
4259 anupam.sin 6048 
 
4303 rajveer 6049 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6050 
    args = markOrdersAsPORaised_args()
6051 
    args.read(iprot)
6052 
    iprot.readMessageEnd()
6053 
    result = markOrdersAsPORaised_result()
6054 
    try:
4369 rajveer 6055 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6056 
    except TransactionServiceException, ex:
6057 
      result.ex = ex
6058 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6059 
    result.write(oprot)
6060 
    oprot.writeMessageEnd()
6061 
    oprot.trans.flush()
4285 rajveer 6062 
 
4303 rajveer 6063 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6064 
    args = markOrdersAsReversalInitiated_args()
6065 
    args.read(iprot)
6066 
    iprot.readMessageEnd()
6067 
    result = markOrdersAsReversalInitiated_result()
6068 
    try:
4369 rajveer 6069 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6070 
    except TransactionServiceException, ex:
6071 
      result.ex = ex
6072 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6073 
    result.write(oprot)
6074 
    oprot.writeMessageEnd()
6075 
    oprot.trans.flush()
6076 
 
6077 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6078 
    args = markOrdersAsNotAvailabke_args()
6079 
    args.read(iprot)
6080 
    iprot.readMessageEnd()
6081 
    result = markOrdersAsNotAvailabke_result()
6082 
    try:
4369 rajveer 6083 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6084 
    except TransactionServiceException, ex:
6085 
      result.ex = ex
6086 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6087 
    result.write(oprot)
6088 
    oprot.writeMessageEnd()
6089 
    oprot.trans.flush()
6090 
 
4369 rajveer 6091 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6092 
    args = markOrdersAsTimeout_args()
6093 
    args.read(iprot)
6094 
    iprot.readMessageEnd()
6095 
    result = markOrdersAsTimeout_result()
6096 
    try:
6097 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6098 
    except TransactionServiceException, ex:
6099 
      result.ex = ex
6100 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6101 
    result.write(oprot)
6102 
    oprot.writeMessageEnd()
6103 
    oprot.trans.flush()
4303 rajveer 6104 
 
4662 rajveer 6105 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6106 
    args = markOrderAsLostInTransit_args()
6107 
    args.read(iprot)
6108 
    iprot.readMessageEnd()
6109 
    result = markOrderAsLostInTransit_result()
6110 
    try:
6111 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6112 
    except TransactionServiceException, ex:
6113 
      result.ex = ex
6114 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6115 
    result.write(oprot)
6116 
    oprot.writeMessageEnd()
6117 
    oprot.trans.flush()
6118 
 
4386 anupam.sin 6119 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6120 
    args = getOrderForAwb_args()
6121 
    args.read(iprot)
6122 
    iprot.readMessageEnd()
6123 
    result = getOrderForAwb_result()
6124 
    try:
6125 
      result.success = self._handler.getOrderForAwb(args.awb)
6126 
    except TransactionServiceException, ex:
6127 
      result.ex = ex
6128 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6129 
    result.write(oprot)
6130 
    oprot.writeMessageEnd()
6131 
    oprot.trans.flush()
4369 rajveer 6132 
 
4506 phani.kuma 6133 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6134 
    args = getOrdersForProviderForStatus_args()
6135 
    args.read(iprot)
6136 
    iprot.readMessageEnd()
6137 
    result = getOrdersForProviderForStatus_result()
6138 
    try:
4910 phani.kuma 6139 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6140 
    except TransactionServiceException, ex:
6141 
      result.ex = ex
6142 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
4386 anupam.sin 6146 
 
4600 varun.gupt 6147 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6148 
    args = getBilledOrdersForVendor_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = getBilledOrdersForVendor_result()
6152 
    try:
6153 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
4506 phani.kuma 6160 
 
4607 rajveer 6161 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6162 
    args = getSlippedSippingDateOrders_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = getSlippedSippingDateOrders_result()
6166 
    try:
6167 
      result.success = self._handler.getSlippedSippingDateOrders()
6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
6170 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
4709 rajveer 6175 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6176 
    args = getCancelledOrders_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = getCancelledOrders_result()
6180 
    try:
6181 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
6184 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
4600 varun.gupt 6189 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6190 
    args = saveBluedartSettlements_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = saveBluedartSettlements_result()
6194 
    try:
6195 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
6198 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
6202 
 
6203 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6204 
    args = savePaymentSettlements_args()
6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
6207 
    result = savePaymentSettlements_result()
6208 
    try:
4905 varun.gupt 6209 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
6212 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
6217 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6218 
    args = saveEBSSettlementSummary_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = saveEBSSettlementSummary_result()
6222 
    try:
6223 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6224 
    except TransactionServiceException, ex:
6225 
      result.ex = ex
6226 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
6230 
 
6231 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
6232 
    args = getSettlementForPaymentId_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = getSettlementForPaymentId_result()
6236 
    try:
6237 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
6238 
    except TransactionServiceException, ex:
6239 
      result.ex = ex
6240 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
6244 
 
6245 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6246 
    args = getEBSSettlementSummaries_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = getEBSSettlementSummaries_result()
6250 
    try:
6251 
      result.success = self._handler.getEBSSettlementSummaries()
6252 
    except TransactionServiceException, ex:
6253 
      result.ex = ex
6254 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
6258 
 
6259 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6260 
    args = markEBSSettlementUploaded_args()
6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
6263 
    result = markEBSSettlementUploaded_result()
6264 
    try:
6265 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6266 
    except TransactionServiceException, ex:
6267 
      result.ex = ex
6268 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
6272 
 
6273 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6274 
    args = getEBSSettlementDate_args()
6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
6277 
    result = getEBSSettlementDate_result()
6278 
    try:
6279 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6280 
    except TransactionServiceException, ex:
6281 
      result.ex = ex
6282 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
6286 
 
4715 varun.gupt 6287 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6288 
    args = getSettlementsByDate_args()
6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
6291 
    result = getSettlementsByDate_result()
6292 
    try:
6293 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6294 
    except TransactionServiceException, ex:
6295 
      result.ex = ex
6296 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
4600 varun.gupt 6300 
 
4715 varun.gupt 6301 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6302 
    args = getReshippedOrderIds_args()
6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
6305 
    result = getReshippedOrderIds_result()
6306 
    try:
6307 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6308 
    except TransactionServiceException, ex:
6309 
      result.ex = ex
6310 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
6314 
 
4757 mandeep.dh 6315 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6316 
    args = updateOrdersAsPORaised_args()
6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
6319 
    result = updateOrdersAsPORaised_result()
6320 
    try:
6321 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6322 
    except TransactionServiceException, ex:
6323 
      result.ex = ex
6324 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6325 
    result.write(oprot)
6326 
    oprot.writeMessageEnd()
6327 
    oprot.trans.flush()
4715 varun.gupt 6328 
 
4875 varun.gupt 6329 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6330 
    args = getOrdersWhereVendorNotPaid_args()
6331 
    args.read(iprot)
6332 
    iprot.readMessageEnd()
6333 
    result = getOrdersWhereVendorNotPaid_result()
6334 
    try:
6335 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6336 
    except TransactionServiceException, ex:
6337 
      result.ex = ex
6338 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
4757 mandeep.dh 6342 
 
4875 varun.gupt 6343 
 
94 ashish 6344 
# HELPER FUNCTIONS AND STRUCTURES
6345 
 
6346 
class createTransaction_args:
6347 
  """
6348 
  Attributes:
6349 
   - transaction
6350 
  """
6351 
 
6352 
  thrift_spec = (
6353 
    None, # 0
6354 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6355 
  )
6356 
 
6357 
  def __init__(self, transaction=None,):
6358 
    self.transaction = transaction
6359 
 
6360 
  def read(self, iprot):
6361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6363 
      return
6364 
    iprot.readStructBegin()
6365 
    while True:
6366 
      (fname, ftype, fid) = iprot.readFieldBegin()
6367 
      if ftype == TType.STOP:
6368 
        break
6369 
      if fid == 1:
6370 
        if ftype == TType.STRUCT:
6371 
          self.transaction = Transaction()
6372 
          self.transaction.read(iprot)
6373 
        else:
6374 
          iprot.skip(ftype)
6375 
      else:
6376 
        iprot.skip(ftype)
6377 
      iprot.readFieldEnd()
6378 
    iprot.readStructEnd()
6379 
 
6380 
  def write(self, oprot):
6381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6383 
      return
6384 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6385 
    if self.transaction is not None:
94 ashish 6386 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6387 
      self.transaction.write(oprot)
6388 
      oprot.writeFieldEnd()
6389 
    oprot.writeFieldStop()
6390 
    oprot.writeStructEnd()
6391 
 
3431 rajveer 6392 
  def validate(self):
6393 
    return
6394 
 
6395 
 
94 ashish 6396 
  def __repr__(self):
6397 
    L = ['%s=%r' % (key, value)
6398 
      for key, value in self.__dict__.iteritems()]
6399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6400 
 
6401 
  def __eq__(self, other):
6402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6403 
 
6404 
  def __ne__(self, other):
6405 
    return not (self == other)
6406 
 
6407 
class createTransaction_result:
6408 
  """
6409 
  Attributes:
132 ashish 6410 
   - success
94 ashish 6411 
   - ex
6412 
  """
6413 
 
6414 
  thrift_spec = (
132 ashish 6415 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6417 
  )
6418 
 
132 ashish 6419 
  def __init__(self, success=None, ex=None,):
6420 
    self.success = success
94 ashish 6421 
    self.ex = ex
6422 
 
6423 
  def read(self, iprot):
6424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6426 
      return
6427 
    iprot.readStructBegin()
6428 
    while True:
6429 
      (fname, ftype, fid) = iprot.readFieldBegin()
6430 
      if ftype == TType.STOP:
6431 
        break
132 ashish 6432 
      if fid == 0:
6433 
        if ftype == TType.I64:
6434 
          self.success = iprot.readI64();
6435 
        else:
6436 
          iprot.skip(ftype)
6437 
      elif fid == 1:
94 ashish 6438 
        if ftype == TType.STRUCT:
6439 
          self.ex = TransactionServiceException()
6440 
          self.ex.read(iprot)
6441 
        else:
6442 
          iprot.skip(ftype)
6443 
      else:
6444 
        iprot.skip(ftype)
6445 
      iprot.readFieldEnd()
6446 
    iprot.readStructEnd()
6447 
 
6448 
  def write(self, oprot):
6449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6451 
      return
6452 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6453 
    if self.success is not None:
132 ashish 6454 
      oprot.writeFieldBegin('success', TType.I64, 0)
6455 
      oprot.writeI64(self.success)
6456 
      oprot.writeFieldEnd()
3431 rajveer 6457 
    if self.ex is not None:
94 ashish 6458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6459 
      self.ex.write(oprot)
6460 
      oprot.writeFieldEnd()
6461 
    oprot.writeFieldStop()
6462 
    oprot.writeStructEnd()
6463 
 
3431 rajveer 6464 
  def validate(self):
6465 
    return
6466 
 
6467 
 
94 ashish 6468 
  def __repr__(self):
6469 
    L = ['%s=%r' % (key, value)
6470 
      for key, value in self.__dict__.iteritems()]
6471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6472 
 
6473 
  def __eq__(self, other):
6474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6475 
 
6476 
  def __ne__(self, other):
6477 
    return not (self == other)
6478 
 
6479 
class getTransaction_args:
6480 
  """
6481 
  Attributes:
6482 
   - id
6483 
  """
6484 
 
6485 
  thrift_spec = (
6486 
    None, # 0
6487 
    (1, TType.I64, 'id', None, None, ), # 1
6488 
  )
6489 
 
6490 
  def __init__(self, id=None,):
6491 
    self.id = id
6492 
 
6493 
  def read(self, iprot):
6494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6496 
      return
6497 
    iprot.readStructBegin()
6498 
    while True:
6499 
      (fname, ftype, fid) = iprot.readFieldBegin()
6500 
      if ftype == TType.STOP:
6501 
        break
6502 
      if fid == 1:
6503 
        if ftype == TType.I64:
6504 
          self.id = iprot.readI64();
6505 
        else:
6506 
          iprot.skip(ftype)
6507 
      else:
6508 
        iprot.skip(ftype)
6509 
      iprot.readFieldEnd()
6510 
    iprot.readStructEnd()
6511 
 
6512 
  def write(self, oprot):
6513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6515 
      return
6516 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6517 
    if self.id is not None:
94 ashish 6518 
      oprot.writeFieldBegin('id', TType.I64, 1)
6519 
      oprot.writeI64(self.id)
6520 
      oprot.writeFieldEnd()
6521 
    oprot.writeFieldStop()
6522 
    oprot.writeStructEnd()
6523 
 
3431 rajveer 6524 
  def validate(self):
6525 
    return
6526 
 
6527 
 
94 ashish 6528 
  def __repr__(self):
6529 
    L = ['%s=%r' % (key, value)
6530 
      for key, value in self.__dict__.iteritems()]
6531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6532 
 
6533 
  def __eq__(self, other):
6534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6535 
 
6536 
  def __ne__(self, other):
6537 
    return not (self == other)
6538 
 
6539 
class getTransaction_result:
6540 
  """
6541 
  Attributes:
6542 
   - success
6543 
   - ex
6544 
  """
6545 
 
6546 
  thrift_spec = (
6547 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6549 
  )
6550 
 
6551 
  def __init__(self, success=None, ex=None,):
6552 
    self.success = success
6553 
    self.ex = ex
6554 
 
6555 
  def read(self, iprot):
6556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6558 
      return
6559 
    iprot.readStructBegin()
6560 
    while True:
6561 
      (fname, ftype, fid) = iprot.readFieldBegin()
6562 
      if ftype == TType.STOP:
6563 
        break
6564 
      if fid == 0:
6565 
        if ftype == TType.STRUCT:
6566 
          self.success = Transaction()
6567 
          self.success.read(iprot)
6568 
        else:
6569 
          iprot.skip(ftype)
6570 
      elif fid == 1:
6571 
        if ftype == TType.STRUCT:
6572 
          self.ex = TransactionServiceException()
6573 
          self.ex.read(iprot)
6574 
        else:
6575 
          iprot.skip(ftype)
6576 
      else:
6577 
        iprot.skip(ftype)
6578 
      iprot.readFieldEnd()
6579 
    iprot.readStructEnd()
6580 
 
6581 
  def write(self, oprot):
6582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6584 
      return
6585 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6586 
    if self.success is not None:
94 ashish 6587 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6588 
      self.success.write(oprot)
6589 
      oprot.writeFieldEnd()
3431 rajveer 6590 
    if self.ex is not None:
94 ashish 6591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6592 
      self.ex.write(oprot)
6593 
      oprot.writeFieldEnd()
6594 
    oprot.writeFieldStop()
6595 
    oprot.writeStructEnd()
6596 
 
3431 rajveer 6597 
  def validate(self):
6598 
    return
6599 
 
6600 
 
94 ashish 6601 
  def __repr__(self):
6602 
    L = ['%s=%r' % (key, value)
6603 
      for key, value in self.__dict__.iteritems()]
6604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6605 
 
6606 
  def __eq__(self, other):
6607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6608 
 
6609 
  def __ne__(self, other):
6610 
    return not (self == other)
6611 
 
6612 
class getTransactionsForCustomer_args:
6613 
  """
6614 
  Attributes:
6615 
   - customerId
6616 
   - from_date
6617 
   - to_date
6618 
   - status
6619 
  """
6620 
 
6621 
  thrift_spec = (
6622 
    None, # 0
6623 
    (1, TType.I64, 'customerId', None, None, ), # 1
6624 
    (2, TType.I64, 'from_date', None, None, ), # 2
6625 
    (3, TType.I64, 'to_date', None, None, ), # 3
6626 
    (4, TType.I32, 'status', None, None, ), # 4
6627 
  )
6628 
 
6629 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6630 
    self.customerId = customerId
6631 
    self.from_date = from_date
6632 
    self.to_date = to_date
6633 
    self.status = status
6634 
 
6635 
  def read(self, iprot):
6636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6638 
      return
6639 
    iprot.readStructBegin()
6640 
    while True:
6641 
      (fname, ftype, fid) = iprot.readFieldBegin()
6642 
      if ftype == TType.STOP:
6643 
        break
6644 
      if fid == 1:
6645 
        if ftype == TType.I64:
6646 
          self.customerId = iprot.readI64();
6647 
        else:
6648 
          iprot.skip(ftype)
6649 
      elif fid == 2:
6650 
        if ftype == TType.I64:
6651 
          self.from_date = iprot.readI64();
6652 
        else:
6653 
          iprot.skip(ftype)
6654 
      elif fid == 3:
6655 
        if ftype == TType.I64:
6656 
          self.to_date = iprot.readI64();
6657 
        else:
6658 
          iprot.skip(ftype)
6659 
      elif fid == 4:
6660 
        if ftype == TType.I32:
6661 
          self.status = iprot.readI32();
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      else:
6665 
        iprot.skip(ftype)
6666 
      iprot.readFieldEnd()
6667 
    iprot.readStructEnd()
6668 
 
6669 
  def write(self, oprot):
6670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6672 
      return
6673 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6674 
    if self.customerId is not None:
94 ashish 6675 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6676 
      oprot.writeI64(self.customerId)
6677 
      oprot.writeFieldEnd()
3431 rajveer 6678 
    if self.from_date is not None:
94 ashish 6679 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6680 
      oprot.writeI64(self.from_date)
6681 
      oprot.writeFieldEnd()
3431 rajveer 6682 
    if self.to_date is not None:
94 ashish 6683 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6684 
      oprot.writeI64(self.to_date)
6685 
      oprot.writeFieldEnd()
3431 rajveer 6686 
    if self.status is not None:
94 ashish 6687 
      oprot.writeFieldBegin('status', TType.I32, 4)
6688 
      oprot.writeI32(self.status)
6689 
      oprot.writeFieldEnd()
6690 
    oprot.writeFieldStop()
6691 
    oprot.writeStructEnd()
6692 
 
3431 rajveer 6693 
  def validate(self):
6694 
    return
6695 
 
6696 
 
94 ashish 6697 
  def __repr__(self):
6698 
    L = ['%s=%r' % (key, value)
6699 
      for key, value in self.__dict__.iteritems()]
6700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6701 
 
6702 
  def __eq__(self, other):
6703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6704 
 
6705 
  def __ne__(self, other):
6706 
    return not (self == other)
6707 
 
6708 
class getTransactionsForCustomer_result:
6709 
  """
6710 
  Attributes:
6711 
   - success
6712 
   - ex
6713 
  """
6714 
 
6715 
  thrift_spec = (
6716 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6718 
  )
6719 
 
6720 
  def __init__(self, success=None, ex=None,):
6721 
    self.success = success
6722 
    self.ex = ex
6723 
 
6724 
  def read(self, iprot):
6725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6727 
      return
6728 
    iprot.readStructBegin()
6729 
    while True:
6730 
      (fname, ftype, fid) = iprot.readFieldBegin()
6731 
      if ftype == TType.STOP:
6732 
        break
6733 
      if fid == 0:
6734 
        if ftype == TType.LIST:
6735 
          self.success = []
4837 varun.gupt 6736 
          (_etype45, _size42) = iprot.readListBegin()
6737 
          for _i46 in xrange(_size42):
6738 
            _elem47 = Transaction()
6739 
            _elem47.read(iprot)
6740 
            self.success.append(_elem47)
94 ashish 6741 
          iprot.readListEnd()
6742 
        else:
6743 
          iprot.skip(ftype)
6744 
      elif fid == 1:
6745 
        if ftype == TType.STRUCT:
6746 
          self.ex = TransactionServiceException()
6747 
          self.ex.read(iprot)
6748 
        else:
6749 
          iprot.skip(ftype)
6750 
      else:
6751 
        iprot.skip(ftype)
6752 
      iprot.readFieldEnd()
6753 
    iprot.readStructEnd()
6754 
 
6755 
  def write(self, oprot):
6756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6758 
      return
6759 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6760 
    if self.success is not None:
94 ashish 6761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6762 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6763 
      for iter48 in self.success:
6764 
        iter48.write(oprot)
94 ashish 6765 
      oprot.writeListEnd()
6766 
      oprot.writeFieldEnd()
3431 rajveer 6767 
    if self.ex is not None:
94 ashish 6768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6769 
      self.ex.write(oprot)
6770 
      oprot.writeFieldEnd()
6771 
    oprot.writeFieldStop()
6772 
    oprot.writeStructEnd()
6773 
 
3431 rajveer 6774 
  def validate(self):
6775 
    return
6776 
 
6777 
 
94 ashish 6778 
  def __repr__(self):
6779 
    L = ['%s=%r' % (key, value)
6780 
      for key, value in self.__dict__.iteritems()]
6781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6782 
 
6783 
  def __eq__(self, other):
6784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6785 
 
6786 
  def __ne__(self, other):
6787 
    return not (self == other)
6788 
 
132 ashish 6789 
class getTransactionsForShoppingCartId_args:
6790 
  """
6791 
  Attributes:
6792 
   - shoppingCartId
6793 
  """
6794 
 
6795 
  thrift_spec = (
6796 
    None, # 0
6797 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6798 
  )
6799 
 
6800 
  def __init__(self, shoppingCartId=None,):
6801 
    self.shoppingCartId = shoppingCartId
6802 
 
6803 
  def read(self, iprot):
6804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6806 
      return
6807 
    iprot.readStructBegin()
6808 
    while True:
6809 
      (fname, ftype, fid) = iprot.readFieldBegin()
6810 
      if ftype == TType.STOP:
6811 
        break
6812 
      if fid == 1:
6813 
        if ftype == TType.I64:
6814 
          self.shoppingCartId = iprot.readI64();
6815 
        else:
6816 
          iprot.skip(ftype)
6817 
      else:
6818 
        iprot.skip(ftype)
6819 
      iprot.readFieldEnd()
6820 
    iprot.readStructEnd()
6821 
 
6822 
  def write(self, oprot):
6823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6825 
      return
6826 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6827 
    if self.shoppingCartId is not None:
132 ashish 6828 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6829 
      oprot.writeI64(self.shoppingCartId)
6830 
      oprot.writeFieldEnd()
6831 
    oprot.writeFieldStop()
6832 
    oprot.writeStructEnd()
6833 
 
3431 rajveer 6834 
  def validate(self):
6835 
    return
6836 
 
6837 
 
132 ashish 6838 
  def __repr__(self):
6839 
    L = ['%s=%r' % (key, value)
6840 
      for key, value in self.__dict__.iteritems()]
6841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6842 
 
6843 
  def __eq__(self, other):
6844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6845 
 
6846 
  def __ne__(self, other):
6847 
    return not (self == other)
6848 
 
6849 
class getTransactionsForShoppingCartId_result:
6850 
  """
6851 
  Attributes:
6852 
   - success
6853 
   - ex
6854 
  """
6855 
 
6856 
  thrift_spec = (
6857 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6859 
  )
6860 
 
6861 
  def __init__(self, success=None, ex=None,):
6862 
    self.success = success
6863 
    self.ex = ex
6864 
 
6865 
  def read(self, iprot):
6866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6868 
      return
6869 
    iprot.readStructBegin()
6870 
    while True:
6871 
      (fname, ftype, fid) = iprot.readFieldBegin()
6872 
      if ftype == TType.STOP:
6873 
        break
6874 
      if fid == 0:
6875 
        if ftype == TType.LIST:
6876 
          self.success = []
4837 varun.gupt 6877 
          (_etype52, _size49) = iprot.readListBegin()
6878 
          for _i53 in xrange(_size49):
6879 
            _elem54 = Transaction()
6880 
            _elem54.read(iprot)
6881 
            self.success.append(_elem54)
132 ashish 6882 
          iprot.readListEnd()
6883 
        else:
6884 
          iprot.skip(ftype)
6885 
      elif fid == 1:
6886 
        if ftype == TType.STRUCT:
6887 
          self.ex = TransactionServiceException()
6888 
          self.ex.read(iprot)
6889 
        else:
6890 
          iprot.skip(ftype)
6891 
      else:
6892 
        iprot.skip(ftype)
6893 
      iprot.readFieldEnd()
6894 
    iprot.readStructEnd()
6895 
 
6896 
  def write(self, oprot):
6897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6899 
      return
6900 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6901 
    if self.success is not None:
132 ashish 6902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6904 
      for iter55 in self.success:
6905 
        iter55.write(oprot)
132 ashish 6906 
      oprot.writeListEnd()
6907 
      oprot.writeFieldEnd()
3431 rajveer 6908 
    if self.ex is not None:
132 ashish 6909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6910 
      self.ex.write(oprot)
6911 
      oprot.writeFieldEnd()
6912 
    oprot.writeFieldStop()
6913 
    oprot.writeStructEnd()
6914 
 
3431 rajveer 6915 
  def validate(self):
6916 
    return
6917 
 
6918 
 
132 ashish 6919 
  def __repr__(self):
6920 
    L = ['%s=%r' % (key, value)
6921 
      for key, value in self.__dict__.iteritems()]
6922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6923 
 
6924 
  def __eq__(self, other):
6925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6926 
 
6927 
  def __ne__(self, other):
6928 
    return not (self == other)
6929 
 
94 ashish 6930 
class getTransactionStatus_args:
6931 
  """
6932 
  Attributes:
6933 
   - transactionId
6934 
  """
6935 
 
6936 
  thrift_spec = (
6937 
    None, # 0
6938 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6939 
  )
6940 
 
6941 
  def __init__(self, transactionId=None,):
6942 
    self.transactionId = transactionId
6943 
 
6944 
  def read(self, iprot):
6945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6947 
      return
6948 
    iprot.readStructBegin()
6949 
    while True:
6950 
      (fname, ftype, fid) = iprot.readFieldBegin()
6951 
      if ftype == TType.STOP:
6952 
        break
6953 
      if fid == 1:
6954 
        if ftype == TType.I64:
6955 
          self.transactionId = iprot.readI64();
6956 
        else:
6957 
          iprot.skip(ftype)
6958 
      else:
6959 
        iprot.skip(ftype)
6960 
      iprot.readFieldEnd()
6961 
    iprot.readStructEnd()
6962 
 
6963 
  def write(self, oprot):
6964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6966 
      return
6967 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6968 
    if self.transactionId is not None:
94 ashish 6969 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6970 
      oprot.writeI64(self.transactionId)
6971 
      oprot.writeFieldEnd()
6972 
    oprot.writeFieldStop()
6973 
    oprot.writeStructEnd()
6974 
 
3431 rajveer 6975 
  def validate(self):
6976 
    return
6977 
 
6978 
 
94 ashish 6979 
  def __repr__(self):
6980 
    L = ['%s=%r' % (key, value)
6981 
      for key, value in self.__dict__.iteritems()]
6982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6983 
 
6984 
  def __eq__(self, other):
6985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6986 
 
6987 
  def __ne__(self, other):
6988 
    return not (self == other)
6989 
 
6990 
class getTransactionStatus_result:
6991 
  """
6992 
  Attributes:
6993 
   - success
6994 
   - ex
6995 
  """
6996 
 
6997 
  thrift_spec = (
6998 
    (0, TType.I32, 'success', None, None, ), # 0
6999 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7000 
  )
7001 
 
7002 
  def __init__(self, success=None, ex=None,):
7003 
    self.success = success
7004 
    self.ex = ex
7005 
 
7006 
  def read(self, iprot):
7007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7009 
      return
7010 
    iprot.readStructBegin()
7011 
    while True:
7012 
      (fname, ftype, fid) = iprot.readFieldBegin()
7013 
      if ftype == TType.STOP:
7014 
        break
7015 
      if fid == 0:
7016 
        if ftype == TType.I32:
7017 
          self.success = iprot.readI32();
7018 
        else:
7019 
          iprot.skip(ftype)
7020 
      elif fid == 1:
7021 
        if ftype == TType.STRUCT:
7022 
          self.ex = TransactionServiceException()
7023 
          self.ex.read(iprot)
7024 
        else:
7025 
          iprot.skip(ftype)
7026 
      else:
7027 
        iprot.skip(ftype)
7028 
      iprot.readFieldEnd()
7029 
    iprot.readStructEnd()
7030 
 
7031 
  def write(self, oprot):
7032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7034 
      return
7035 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7036 
    if self.success is not None:
94 ashish 7037 
      oprot.writeFieldBegin('success', TType.I32, 0)
7038 
      oprot.writeI32(self.success)
7039 
      oprot.writeFieldEnd()
3431 rajveer 7040 
    if self.ex is not None:
94 ashish 7041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7042 
      self.ex.write(oprot)
7043 
      oprot.writeFieldEnd()
7044 
    oprot.writeFieldStop()
7045 
    oprot.writeStructEnd()
7046 
 
3431 rajveer 7047 
  def validate(self):
7048 
    return
7049 
 
7050 
 
94 ashish 7051 
  def __repr__(self):
7052 
    L = ['%s=%r' % (key, value)
7053 
      for key, value in self.__dict__.iteritems()]
7054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7055 
 
7056 
  def __eq__(self, other):
7057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7058 
 
7059 
  def __ne__(self, other):
7060 
    return not (self == other)
7061 
 
7062 
class changeTransactionStatus_args:
7063 
  """
7064 
  Attributes:
7065 
   - transactionId
7066 
   - status
7067 
   - description
7068 
  """
7069 
 
7070 
  thrift_spec = (
7071 
    None, # 0
7072 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7073 
    (2, TType.I32, 'status', None, None, ), # 2
7074 
    (3, TType.STRING, 'description', None, None, ), # 3
7075 
  )
7076 
 
7077 
  def __init__(self, transactionId=None, status=None, description=None,):
7078 
    self.transactionId = transactionId
7079 
    self.status = status
7080 
    self.description = description
7081 
 
7082 
  def read(self, iprot):
7083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7085 
      return
7086 
    iprot.readStructBegin()
7087 
    while True:
7088 
      (fname, ftype, fid) = iprot.readFieldBegin()
7089 
      if ftype == TType.STOP:
7090 
        break
7091 
      if fid == 1:
7092 
        if ftype == TType.I64:
7093 
          self.transactionId = iprot.readI64();
7094 
        else:
7095 
          iprot.skip(ftype)
7096 
      elif fid == 2:
7097 
        if ftype == TType.I32:
7098 
          self.status = iprot.readI32();
7099 
        else:
7100 
          iprot.skip(ftype)
7101 
      elif fid == 3:
7102 
        if ftype == TType.STRING:
7103 
          self.description = iprot.readString();
7104 
        else:
7105 
          iprot.skip(ftype)
7106 
      else:
7107 
        iprot.skip(ftype)
7108 
      iprot.readFieldEnd()
7109 
    iprot.readStructEnd()
7110 
 
7111 
  def write(self, oprot):
7112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7114 
      return
7115 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7116 
    if self.transactionId is not None:
94 ashish 7117 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7118 
      oprot.writeI64(self.transactionId)
7119 
      oprot.writeFieldEnd()
3431 rajveer 7120 
    if self.status is not None:
94 ashish 7121 
      oprot.writeFieldBegin('status', TType.I32, 2)
7122 
      oprot.writeI32(self.status)
7123 
      oprot.writeFieldEnd()
3431 rajveer 7124 
    if self.description is not None:
94 ashish 7125 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7126 
      oprot.writeString(self.description)
7127 
      oprot.writeFieldEnd()
7128 
    oprot.writeFieldStop()
7129 
    oprot.writeStructEnd()
7130 
 
3431 rajveer 7131 
  def validate(self):
7132 
    return
7133 
 
7134 
 
94 ashish 7135 
  def __repr__(self):
7136 
    L = ['%s=%r' % (key, value)
7137 
      for key, value in self.__dict__.iteritems()]
7138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7139 
 
7140 
  def __eq__(self, other):
7141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7142 
 
7143 
  def __ne__(self, other):
7144 
    return not (self == other)
7145 
 
7146 
class changeTransactionStatus_result:
7147 
  """
7148 
  Attributes:
7149 
   - success
7150 
   - ex
7151 
  """
7152 
 
7153 
  thrift_spec = (
7154 
    (0, TType.BOOL, 'success', None, None, ), # 0
7155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7156 
  )
7157 
 
7158 
  def __init__(self, success=None, ex=None,):
7159 
    self.success = success
7160 
    self.ex = ex
7161 
 
7162 
  def read(self, iprot):
7163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7165 
      return
7166 
    iprot.readStructBegin()
7167 
    while True:
7168 
      (fname, ftype, fid) = iprot.readFieldBegin()
7169 
      if ftype == TType.STOP:
7170 
        break
7171 
      if fid == 0:
7172 
        if ftype == TType.BOOL:
7173 
          self.success = iprot.readBool();
7174 
        else:
7175 
          iprot.skip(ftype)
7176 
      elif fid == 1:
7177 
        if ftype == TType.STRUCT:
7178 
          self.ex = TransactionServiceException()
7179 
          self.ex.read(iprot)
7180 
        else:
7181 
          iprot.skip(ftype)
7182 
      else:
7183 
        iprot.skip(ftype)
7184 
      iprot.readFieldEnd()
7185 
    iprot.readStructEnd()
7186 
 
7187 
  def write(self, oprot):
7188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7190 
      return
7191 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7192 
    if self.success is not None:
94 ashish 7193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7194 
      oprot.writeBool(self.success)
7195 
      oprot.writeFieldEnd()
3431 rajveer 7196 
    if self.ex is not None:
94 ashish 7197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7198 
      self.ex.write(oprot)
7199 
      oprot.writeFieldEnd()
7200 
    oprot.writeFieldStop()
7201 
    oprot.writeStructEnd()
7202 
 
3431 rajveer 7203 
  def validate(self):
7204 
    return
7205 
 
7206 
 
94 ashish 7207 
  def __repr__(self):
7208 
    L = ['%s=%r' % (key, value)
7209 
      for key, value in self.__dict__.iteritems()]
7210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7211 
 
7212 
  def __eq__(self, other):
7213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7214 
 
7215 
  def __ne__(self, other):
7216 
    return not (self == other)
7217 
 
1398 varun.gupt 7218 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7219 
  """
7220 
  Attributes:
7221 
   - transactionId
7222 
  """
7223 
 
7224 
  thrift_spec = (
7225 
    None, # 0
7226 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7227 
  )
7228 
 
7229 
  def __init__(self, transactionId=None,):
7230 
    self.transactionId = transactionId
7231 
 
7232 
  def read(self, iprot):
7233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7235 
      return
7236 
    iprot.readStructBegin()
7237 
    while True:
7238 
      (fname, ftype, fid) = iprot.readFieldBegin()
7239 
      if ftype == TType.STOP:
7240 
        break
7241 
      if fid == 1:
7242 
        if ftype == TType.I64:
7243 
          self.transactionId = iprot.readI64();
7244 
        else:
7245 
          iprot.skip(ftype)
7246 
      else:
7247 
        iprot.skip(ftype)
7248 
      iprot.readFieldEnd()
7249 
    iprot.readStructEnd()
7250 
 
7251 
  def write(self, oprot):
7252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7254 
      return
1398 varun.gupt 7255 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7256 
    if self.transactionId is not None:
1382 varun.gupt 7257 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7258 
      oprot.writeI64(self.transactionId)
7259 
      oprot.writeFieldEnd()
7260 
    oprot.writeFieldStop()
7261 
    oprot.writeStructEnd()
7262 
 
3431 rajveer 7263 
  def validate(self):
7264 
    return
7265 
 
7266 
 
1382 varun.gupt 7267 
  def __repr__(self):
7268 
    L = ['%s=%r' % (key, value)
7269 
      for key, value in self.__dict__.iteritems()]
7270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7271 
 
7272 
  def __eq__(self, other):
7273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7274 
 
7275 
  def __ne__(self, other):
7276 
    return not (self == other)
7277 
 
1398 varun.gupt 7278 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7279 
  """
7280 
  Attributes:
7281 
   - success
7282 
   - ex
7283 
  """
7284 
 
7285 
  thrift_spec = (
7286 
    (0, TType.BOOL, 'success', None, None, ), # 0
7287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7288 
  )
7289 
 
7290 
  def __init__(self, success=None, ex=None,):
7291 
    self.success = success
7292 
    self.ex = ex
7293 
 
7294 
  def read(self, iprot):
7295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7297 
      return
7298 
    iprot.readStructBegin()
7299 
    while True:
7300 
      (fname, ftype, fid) = iprot.readFieldBegin()
7301 
      if ftype == TType.STOP:
7302 
        break
7303 
      if fid == 0:
7304 
        if ftype == TType.BOOL:
7305 
          self.success = iprot.readBool();
7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      elif fid == 1:
7309 
        if ftype == TType.STRUCT:
7310 
          self.ex = TransactionServiceException()
7311 
          self.ex.read(iprot)
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      else:
7315 
        iprot.skip(ftype)
7316 
      iprot.readFieldEnd()
7317 
    iprot.readStructEnd()
7318 
 
7319 
  def write(self, oprot):
7320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7322 
      return
1398 varun.gupt 7323 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7324 
    if self.success is not None:
1382 varun.gupt 7325 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7326 
      oprot.writeBool(self.success)
7327 
      oprot.writeFieldEnd()
3431 rajveer 7328 
    if self.ex is not None:
1382 varun.gupt 7329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7330 
      self.ex.write(oprot)
7331 
      oprot.writeFieldEnd()
7332 
    oprot.writeFieldStop()
7333 
    oprot.writeStructEnd()
7334 
 
3431 rajveer 7335 
  def validate(self):
7336 
    return
7337 
 
7338 
 
1382 varun.gupt 7339 
  def __repr__(self):
7340 
    L = ['%s=%r' % (key, value)
7341 
      for key, value in self.__dict__.iteritems()]
7342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7343 
 
7344 
  def __eq__(self, other):
7345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7346 
 
7347 
  def __ne__(self, other):
7348 
    return not (self == other)
7349 
 
483 rajveer 7350 
class getAllOrders_args:
94 ashish 7351 
  """
7352 
  Attributes:
4801 anupam.sin 7353 
   - statuses
483 rajveer 7354 
   - from_date
7355 
   - to_date
7356 
   - warehouse_id
94 ashish 7357 
  """
7358 
 
7359 
  thrift_spec = (
7360 
    None, # 0
4801 anupam.sin 7361 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7362 
    (2, TType.I64, 'from_date', None, None, ), # 2
7363 
    (3, TType.I64, 'to_date', None, None, ), # 3
7364 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7365 
  )
7366 
 
4801 anupam.sin 7367 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7368 
    self.statuses = statuses
483 rajveer 7369 
    self.from_date = from_date
7370 
    self.to_date = to_date
7371 
    self.warehouse_id = warehouse_id
94 ashish 7372 
 
7373 
  def read(self, iprot):
7374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7376 
      return
7377 
    iprot.readStructBegin()
7378 
    while True:
7379 
      (fname, ftype, fid) = iprot.readFieldBegin()
7380 
      if ftype == TType.STOP:
7381 
        break
7382 
      if fid == 1:
4801 anupam.sin 7383 
        if ftype == TType.LIST:
7384 
          self.statuses = []
4837 varun.gupt 7385 
          (_etype59, _size56) = iprot.readListBegin()
7386 
          for _i60 in xrange(_size56):
7387 
            _elem61 = iprot.readI32();
7388 
            self.statuses.append(_elem61)
4801 anupam.sin 7389 
          iprot.readListEnd()
94 ashish 7390 
        else:
7391 
          iprot.skip(ftype)
483 rajveer 7392 
      elif fid == 2:
7393 
        if ftype == TType.I64:
7394 
          self.from_date = iprot.readI64();
94 ashish 7395 
        else:
7396 
          iprot.skip(ftype)
483 rajveer 7397 
      elif fid == 3:
7398 
        if ftype == TType.I64:
7399 
          self.to_date = iprot.readI64();
94 ashish 7400 
        else:
7401 
          iprot.skip(ftype)
483 rajveer 7402 
      elif fid == 4:
94 ashish 7403 
        if ftype == TType.I64:
483 rajveer 7404 
          self.warehouse_id = iprot.readI64();
94 ashish 7405 
        else:
7406 
          iprot.skip(ftype)
7407 
      else:
7408 
        iprot.skip(ftype)
7409 
      iprot.readFieldEnd()
7410 
    iprot.readStructEnd()
7411 
 
7412 
  def write(self, oprot):
7413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7415 
      return
483 rajveer 7416 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7417 
    if self.statuses is not None:
7418 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7419 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7420 
      for iter62 in self.statuses:
7421 
        oprot.writeI32(iter62)
4801 anupam.sin 7422 
      oprot.writeListEnd()
94 ashish 7423 
      oprot.writeFieldEnd()
3431 rajveer 7424 
    if self.from_date is not None:
483 rajveer 7425 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7426 
      oprot.writeI64(self.from_date)
94 ashish 7427 
      oprot.writeFieldEnd()
3431 rajveer 7428 
    if self.to_date is not None:
483 rajveer 7429 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7430 
      oprot.writeI64(self.to_date)
94 ashish 7431 
      oprot.writeFieldEnd()
3431 rajveer 7432 
    if self.warehouse_id is not None:
483 rajveer 7433 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7434 
      oprot.writeI64(self.warehouse_id)
94 ashish 7435 
      oprot.writeFieldEnd()
7436 
    oprot.writeFieldStop()
7437 
    oprot.writeStructEnd()
7438 
 
3431 rajveer 7439 
  def validate(self):
7440 
    return
7441 
 
7442 
 
94 ashish 7443 
  def __repr__(self):
7444 
    L = ['%s=%r' % (key, value)
7445 
      for key, value in self.__dict__.iteritems()]
7446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7447 
 
7448 
  def __eq__(self, other):
7449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7450 
 
7451 
  def __ne__(self, other):
7452 
    return not (self == other)
7453 
 
483 rajveer 7454 
class getAllOrders_result:
94 ashish 7455 
  """
7456 
  Attributes:
7457 
   - success
7458 
   - ex
7459 
  """
7460 
 
7461 
  thrift_spec = (
483 rajveer 7462 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7464 
  )
7465 
 
7466 
  def __init__(self, success=None, ex=None,):
7467 
    self.success = success
7468 
    self.ex = ex
7469 
 
7470 
  def read(self, iprot):
7471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7473 
      return
7474 
    iprot.readStructBegin()
7475 
    while True:
7476 
      (fname, ftype, fid) = iprot.readFieldBegin()
7477 
      if ftype == TType.STOP:
7478 
        break
7479 
      if fid == 0:
483 rajveer 7480 
        if ftype == TType.LIST:
7481 
          self.success = []
4837 varun.gupt 7482 
          (_etype66, _size63) = iprot.readListBegin()
7483 
          for _i67 in xrange(_size63):
7484 
            _elem68 = Order()
7485 
            _elem68.read(iprot)
7486 
            self.success.append(_elem68)
483 rajveer 7487 
          iprot.readListEnd()
94 ashish 7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      elif fid == 1:
7491 
        if ftype == TType.STRUCT:
7492 
          self.ex = TransactionServiceException()
7493 
          self.ex.read(iprot)
7494 
        else:
7495 
          iprot.skip(ftype)
7496 
      else:
7497 
        iprot.skip(ftype)
7498 
      iprot.readFieldEnd()
7499 
    iprot.readStructEnd()
7500 
 
7501 
  def write(self, oprot):
7502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7504 
      return
483 rajveer 7505 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7506 
    if self.success is not None:
483 rajveer 7507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7509 
      for iter69 in self.success:
7510 
        iter69.write(oprot)
483 rajveer 7511 
      oprot.writeListEnd()
94 ashish 7512 
      oprot.writeFieldEnd()
3431 rajveer 7513 
    if self.ex is not None:
94 ashish 7514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7515 
      self.ex.write(oprot)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
3431 rajveer 7520 
  def validate(self):
7521 
    return
7522 
 
7523 
 
94 ashish 7524 
  def __repr__(self):
7525 
    L = ['%s=%r' % (key, value)
7526 
      for key, value in self.__dict__.iteritems()]
7527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7528 
 
7529 
  def __eq__(self, other):
7530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7531 
 
7532 
  def __ne__(self, other):
7533 
    return not (self == other)
7534 
 
4133 chandransh 7535 
class getOrdersInBatch_args:
7536 
  """
7537 
  Attributes:
7538 
   - statuses
7539 
   - offset
7540 
   - limit
7541 
   - warehouse_id
7542 
  """
7543 
 
7544 
  thrift_spec = (
7545 
    None, # 0
7546 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7547 
    (2, TType.I64, 'offset', None, None, ), # 2
7548 
    (3, TType.I64, 'limit', None, None, ), # 3
7549 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7550 
  )
7551 
 
7552 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7553 
    self.statuses = statuses
7554 
    self.offset = offset
7555 
    self.limit = limit
7556 
    self.warehouse_id = warehouse_id
7557 
 
7558 
  def read(self, iprot):
7559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7561 
      return
7562 
    iprot.readStructBegin()
7563 
    while True:
7564 
      (fname, ftype, fid) = iprot.readFieldBegin()
7565 
      if ftype == TType.STOP:
7566 
        break
7567 
      if fid == 1:
7568 
        if ftype == TType.LIST:
7569 
          self.statuses = []
4837 varun.gupt 7570 
          (_etype73, _size70) = iprot.readListBegin()
7571 
          for _i74 in xrange(_size70):
7572 
            _elem75 = iprot.readI32();
7573 
            self.statuses.append(_elem75)
4133 chandransh 7574 
          iprot.readListEnd()
7575 
        else:
7576 
          iprot.skip(ftype)
7577 
      elif fid == 2:
7578 
        if ftype == TType.I64:
7579 
          self.offset = iprot.readI64();
7580 
        else:
7581 
          iprot.skip(ftype)
7582 
      elif fid == 3:
7583 
        if ftype == TType.I64:
7584 
          self.limit = iprot.readI64();
7585 
        else:
7586 
          iprot.skip(ftype)
7587 
      elif fid == 4:
7588 
        if ftype == TType.I64:
7589 
          self.warehouse_id = iprot.readI64();
7590 
        else:
7591 
          iprot.skip(ftype)
7592 
      else:
7593 
        iprot.skip(ftype)
7594 
      iprot.readFieldEnd()
7595 
    iprot.readStructEnd()
7596 
 
7597 
  def write(self, oprot):
7598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7600 
      return
7601 
    oprot.writeStructBegin('getOrdersInBatch_args')
7602 
    if self.statuses is not None:
7603 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7604 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7605 
      for iter76 in self.statuses:
7606 
        oprot.writeI32(iter76)
4133 chandransh 7607 
      oprot.writeListEnd()
7608 
      oprot.writeFieldEnd()
7609 
    if self.offset is not None:
7610 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7611 
      oprot.writeI64(self.offset)
7612 
      oprot.writeFieldEnd()
7613 
    if self.limit is not None:
7614 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7615 
      oprot.writeI64(self.limit)
7616 
      oprot.writeFieldEnd()
7617 
    if self.warehouse_id is not None:
7618 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7619 
      oprot.writeI64(self.warehouse_id)
7620 
      oprot.writeFieldEnd()
7621 
    oprot.writeFieldStop()
7622 
    oprot.writeStructEnd()
7623 
 
7624 
  def validate(self):
7625 
    return
7626 
 
7627 
 
7628 
  def __repr__(self):
7629 
    L = ['%s=%r' % (key, value)
7630 
      for key, value in self.__dict__.iteritems()]
7631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7632 
 
7633 
  def __eq__(self, other):
7634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7635 
 
7636 
  def __ne__(self, other):
7637 
    return not (self == other)
7638 
 
7639 
class getOrdersInBatch_result:
7640 
  """
7641 
  Attributes:
7642 
   - success
7643 
   - ex
7644 
  """
7645 
 
7646 
  thrift_spec = (
7647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7648 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7649 
  )
7650 
 
7651 
  def __init__(self, success=None, ex=None,):
7652 
    self.success = success
7653 
    self.ex = ex
7654 
 
7655 
  def read(self, iprot):
7656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7658 
      return
7659 
    iprot.readStructBegin()
7660 
    while True:
7661 
      (fname, ftype, fid) = iprot.readFieldBegin()
7662 
      if ftype == TType.STOP:
7663 
        break
7664 
      if fid == 0:
7665 
        if ftype == TType.LIST:
7666 
          self.success = []
4837 varun.gupt 7667 
          (_etype80, _size77) = iprot.readListBegin()
7668 
          for _i81 in xrange(_size77):
7669 
            _elem82 = Order()
7670 
            _elem82.read(iprot)
7671 
            self.success.append(_elem82)
4133 chandransh 7672 
          iprot.readListEnd()
7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      elif fid == 1:
7676 
        if ftype == TType.STRUCT:
7677 
          self.ex = TransactionServiceException()
7678 
          self.ex.read(iprot)
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      else:
7682 
        iprot.skip(ftype)
7683 
      iprot.readFieldEnd()
7684 
    iprot.readStructEnd()
7685 
 
7686 
  def write(self, oprot):
7687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7689 
      return
7690 
    oprot.writeStructBegin('getOrdersInBatch_result')
7691 
    if self.success is not None:
7692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7693 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7694 
      for iter83 in self.success:
7695 
        iter83.write(oprot)
4133 chandransh 7696 
      oprot.writeListEnd()
7697 
      oprot.writeFieldEnd()
7698 
    if self.ex is not None:
7699 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7700 
      self.ex.write(oprot)
7701 
      oprot.writeFieldEnd()
7702 
    oprot.writeFieldStop()
7703 
    oprot.writeStructEnd()
7704 
 
7705 
  def validate(self):
7706 
    return
7707 
 
7708 
 
7709 
  def __repr__(self):
7710 
    L = ['%s=%r' % (key, value)
7711 
      for key, value in self.__dict__.iteritems()]
7712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7713 
 
7714 
  def __eq__(self, other):
7715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7716 
 
7717 
  def __ne__(self, other):
7718 
    return not (self == other)
7719 
 
7720 
class getOrderCount_args:
7721 
  """
7722 
  Attributes:
7723 
   - statuses
7724 
   - warehouseId
7725 
  """
7726 
 
7727 
  thrift_spec = (
7728 
    None, # 0
7729 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7730 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7731 
  )
7732 
 
7733 
  def __init__(self, statuses=None, warehouseId=None,):
7734 
    self.statuses = statuses
7735 
    self.warehouseId = warehouseId
7736 
 
7737 
  def read(self, iprot):
7738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7740 
      return
7741 
    iprot.readStructBegin()
7742 
    while True:
7743 
      (fname, ftype, fid) = iprot.readFieldBegin()
7744 
      if ftype == TType.STOP:
7745 
        break
7746 
      if fid == 1:
7747 
        if ftype == TType.LIST:
7748 
          self.statuses = []
4837 varun.gupt 7749 
          (_etype87, _size84) = iprot.readListBegin()
7750 
          for _i88 in xrange(_size84):
7751 
            _elem89 = iprot.readI32();
7752 
            self.statuses.append(_elem89)
4133 chandransh 7753 
          iprot.readListEnd()
7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      elif fid == 2:
7757 
        if ftype == TType.I64:
7758 
          self.warehouseId = iprot.readI64();
7759 
        else:
7760 
          iprot.skip(ftype)
7761 
      else:
7762 
        iprot.skip(ftype)
7763 
      iprot.readFieldEnd()
7764 
    iprot.readStructEnd()
7765 
 
7766 
  def write(self, oprot):
7767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7769 
      return
7770 
    oprot.writeStructBegin('getOrderCount_args')
7771 
    if self.statuses is not None:
7772 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7773 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7774 
      for iter90 in self.statuses:
7775 
        oprot.writeI32(iter90)
4133 chandransh 7776 
      oprot.writeListEnd()
7777 
      oprot.writeFieldEnd()
7778 
    if self.warehouseId is not None:
7779 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7780 
      oprot.writeI64(self.warehouseId)
7781 
      oprot.writeFieldEnd()
7782 
    oprot.writeFieldStop()
7783 
    oprot.writeStructEnd()
7784 
 
7785 
  def validate(self):
7786 
    return
7787 
 
7788 
 
7789 
  def __repr__(self):
7790 
    L = ['%s=%r' % (key, value)
7791 
      for key, value in self.__dict__.iteritems()]
7792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7793 
 
7794 
  def __eq__(self, other):
7795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7796 
 
7797 
  def __ne__(self, other):
7798 
    return not (self == other)
7799 
 
7800 
class getOrderCount_result:
7801 
  """
7802 
  Attributes:
7803 
   - success
7804 
   - ex
7805 
  """
7806 
 
7807 
  thrift_spec = (
7808 
    (0, TType.I32, 'success', None, None, ), # 0
7809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7810 
  )
7811 
 
7812 
  def __init__(self, success=None, ex=None,):
7813 
    self.success = success
7814 
    self.ex = ex
7815 
 
7816 
  def read(self, iprot):
7817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7819 
      return
7820 
    iprot.readStructBegin()
7821 
    while True:
7822 
      (fname, ftype, fid) = iprot.readFieldBegin()
7823 
      if ftype == TType.STOP:
7824 
        break
7825 
      if fid == 0:
7826 
        if ftype == TType.I32:
7827 
          self.success = iprot.readI32();
7828 
        else:
7829 
          iprot.skip(ftype)
7830 
      elif fid == 1:
7831 
        if ftype == TType.STRUCT:
7832 
          self.ex = TransactionServiceException()
7833 
          self.ex.read(iprot)
7834 
        else:
7835 
          iprot.skip(ftype)
7836 
      else:
7837 
        iprot.skip(ftype)
7838 
      iprot.readFieldEnd()
7839 
    iprot.readStructEnd()
7840 
 
7841 
  def write(self, oprot):
7842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7844 
      return
7845 
    oprot.writeStructBegin('getOrderCount_result')
7846 
    if self.success is not None:
7847 
      oprot.writeFieldBegin('success', TType.I32, 0)
7848 
      oprot.writeI32(self.success)
7849 
      oprot.writeFieldEnd()
7850 
    if self.ex is not None:
7851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7852 
      self.ex.write(oprot)
7853 
      oprot.writeFieldEnd()
7854 
    oprot.writeFieldStop()
7855 
    oprot.writeStructEnd()
7856 
 
7857 
  def validate(self):
7858 
    return
7859 
 
7860 
 
7861 
  def __repr__(self):
7862 
    L = ['%s=%r' % (key, value)
7863 
      for key, value in self.__dict__.iteritems()]
7864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7865 
 
7866 
  def __eq__(self, other):
7867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7868 
 
7869 
  def __ne__(self, other):
7870 
    return not (self == other)
7871 
 
999 varun.gupt 7872 
class getOrdersByBillingDate_args:
7873 
  """
7874 
  Attributes:
7875 
   - status
7876 
   - start_billing_date
7877 
   - end_billing_date
7878 
   - warehouse_id
7879 
  """
7880 
 
7881 
  thrift_spec = (
7882 
    None, # 0
7883 
    (1, TType.I32, 'status', None, None, ), # 1
7884 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7885 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7886 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7887 
  )
7888 
 
7889 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7890 
    self.status = status
7891 
    self.start_billing_date = start_billing_date
7892 
    self.end_billing_date = end_billing_date
7893 
    self.warehouse_id = warehouse_id
7894 
 
7895 
  def read(self, iprot):
7896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7898 
      return
7899 
    iprot.readStructBegin()
7900 
    while True:
7901 
      (fname, ftype, fid) = iprot.readFieldBegin()
7902 
      if ftype == TType.STOP:
7903 
        break
7904 
      if fid == 1:
7905 
        if ftype == TType.I32:
7906 
          self.status = iprot.readI32();
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      elif fid == 2:
7910 
        if ftype == TType.I64:
7911 
          self.start_billing_date = iprot.readI64();
7912 
        else:
7913 
          iprot.skip(ftype)
7914 
      elif fid == 3:
7915 
        if ftype == TType.I64:
7916 
          self.end_billing_date = iprot.readI64();
7917 
        else:
7918 
          iprot.skip(ftype)
7919 
      elif fid == 4:
7920 
        if ftype == TType.I64:
7921 
          self.warehouse_id = iprot.readI64();
7922 
        else:
7923 
          iprot.skip(ftype)
7924 
      else:
7925 
        iprot.skip(ftype)
7926 
      iprot.readFieldEnd()
7927 
    iprot.readStructEnd()
7928 
 
7929 
  def write(self, oprot):
7930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7932 
      return
7933 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7934 
    if self.status is not None:
999 varun.gupt 7935 
      oprot.writeFieldBegin('status', TType.I32, 1)
7936 
      oprot.writeI32(self.status)
7937 
      oprot.writeFieldEnd()
3431 rajveer 7938 
    if self.start_billing_date is not None:
999 varun.gupt 7939 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7940 
      oprot.writeI64(self.start_billing_date)
7941 
      oprot.writeFieldEnd()
3431 rajveer 7942 
    if self.end_billing_date is not None:
999 varun.gupt 7943 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7944 
      oprot.writeI64(self.end_billing_date)
7945 
      oprot.writeFieldEnd()
3431 rajveer 7946 
    if self.warehouse_id is not None:
999 varun.gupt 7947 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7948 
      oprot.writeI64(self.warehouse_id)
7949 
      oprot.writeFieldEnd()
7950 
    oprot.writeFieldStop()
7951 
    oprot.writeStructEnd()
7952 
 
3431 rajveer 7953 
  def validate(self):
7954 
    return
7955 
 
7956 
 
999 varun.gupt 7957 
  def __repr__(self):
7958 
    L = ['%s=%r' % (key, value)
7959 
      for key, value in self.__dict__.iteritems()]
7960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7961 
 
7962 
  def __eq__(self, other):
7963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7964 
 
7965 
  def __ne__(self, other):
7966 
    return not (self == other)
7967 
 
7968 
class getOrdersByBillingDate_result:
7969 
  """
7970 
  Attributes:
7971 
   - success
7972 
   - ex
7973 
  """
7974 
 
7975 
  thrift_spec = (
7976 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7978 
  )
7979 
 
7980 
  def __init__(self, success=None, ex=None,):
7981 
    self.success = success
7982 
    self.ex = ex
7983 
 
7984 
  def read(self, iprot):
7985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7987 
      return
7988 
    iprot.readStructBegin()
7989 
    while True:
7990 
      (fname, ftype, fid) = iprot.readFieldBegin()
7991 
      if ftype == TType.STOP:
7992 
        break
7993 
      if fid == 0:
7994 
        if ftype == TType.LIST:
7995 
          self.success = []
4837 varun.gupt 7996 
          (_etype94, _size91) = iprot.readListBegin()
7997 
          for _i95 in xrange(_size91):
7998 
            _elem96 = Order()
7999 
            _elem96.read(iprot)
8000 
            self.success.append(_elem96)
999 varun.gupt 8001 
          iprot.readListEnd()
8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 1:
8005 
        if ftype == TType.STRUCT:
8006 
          self.ex = TransactionServiceException()
8007 
          self.ex.read(iprot)
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      else:
8011 
        iprot.skip(ftype)
8012 
      iprot.readFieldEnd()
8013 
    iprot.readStructEnd()
8014 
 
8015 
  def write(self, oprot):
8016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8018 
      return
8019 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8020 
    if self.success is not None:
999 varun.gupt 8021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8023 
      for iter97 in self.success:
8024 
        iter97.write(oprot)
999 varun.gupt 8025 
      oprot.writeListEnd()
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ex is not None:
999 varun.gupt 8028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8029 
      self.ex.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
999 varun.gupt 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
3427 chandransh 8049 
class getOrdersByShippingDate_args:
8050 
  """
8051 
  Attributes:
8052 
   - fromShippingDate
8053 
   - toShippingDate
8054 
   - providerId
8055 
   - warehouseId
3451 chandransh 8056 
   - cod
3427 chandransh 8057 
  """
8058 
 
8059 
  thrift_spec = (
8060 
    None, # 0
8061 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8062 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8063 
    (3, TType.I64, 'providerId', None, None, ), # 3
8064 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8065 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8066 
  )
8067 
 
3451 chandransh 8068 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8069 
    self.fromShippingDate = fromShippingDate
8070 
    self.toShippingDate = toShippingDate
8071 
    self.providerId = providerId
8072 
    self.warehouseId = warehouseId
3451 chandransh 8073 
    self.cod = cod
3427 chandransh 8074 
 
8075 
  def read(self, iprot):
8076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8078 
      return
8079 
    iprot.readStructBegin()
8080 
    while True:
8081 
      (fname, ftype, fid) = iprot.readFieldBegin()
8082 
      if ftype == TType.STOP:
8083 
        break
8084 
      if fid == 1:
8085 
        if ftype == TType.I64:
8086 
          self.fromShippingDate = iprot.readI64();
8087 
        else:
8088 
          iprot.skip(ftype)
8089 
      elif fid == 2:
8090 
        if ftype == TType.I64:
8091 
          self.toShippingDate = iprot.readI64();
8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      elif fid == 3:
8095 
        if ftype == TType.I64:
8096 
          self.providerId = iprot.readI64();
8097 
        else:
8098 
          iprot.skip(ftype)
8099 
      elif fid == 4:
8100 
        if ftype == TType.I64:
8101 
          self.warehouseId = iprot.readI64();
8102 
        else:
8103 
          iprot.skip(ftype)
3451 chandransh 8104 
      elif fid == 5:
8105 
        if ftype == TType.BOOL:
8106 
          self.cod = iprot.readBool();
8107 
        else:
8108 
          iprot.skip(ftype)
3427 chandransh 8109 
      else:
8110 
        iprot.skip(ftype)
8111 
      iprot.readFieldEnd()
8112 
    iprot.readStructEnd()
8113 
 
8114 
  def write(self, oprot):
8115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8117 
      return
8118 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8119 
    if self.fromShippingDate is not None:
3427 chandransh 8120 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8121 
      oprot.writeI64(self.fromShippingDate)
8122 
      oprot.writeFieldEnd()
3431 rajveer 8123 
    if self.toShippingDate is not None:
3427 chandransh 8124 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8125 
      oprot.writeI64(self.toShippingDate)
8126 
      oprot.writeFieldEnd()
3431 rajveer 8127 
    if self.providerId is not None:
3427 chandransh 8128 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8129 
      oprot.writeI64(self.providerId)
8130 
      oprot.writeFieldEnd()
3431 rajveer 8131 
    if self.warehouseId is not None:
3427 chandransh 8132 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8133 
      oprot.writeI64(self.warehouseId)
8134 
      oprot.writeFieldEnd()
3451 chandransh 8135 
    if self.cod is not None:
8136 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8137 
      oprot.writeBool(self.cod)
8138 
      oprot.writeFieldEnd()
3427 chandransh 8139 
    oprot.writeFieldStop()
8140 
    oprot.writeStructEnd()
8141 
 
3431 rajveer 8142 
  def validate(self):
8143 
    return
8144 
 
8145 
 
3427 chandransh 8146 
  def __repr__(self):
8147 
    L = ['%s=%r' % (key, value)
8148 
      for key, value in self.__dict__.iteritems()]
8149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8150 
 
8151 
  def __eq__(self, other):
8152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8153 
 
8154 
  def __ne__(self, other):
8155 
    return not (self == other)
8156 
 
8157 
class getOrdersByShippingDate_result:
8158 
  """
8159 
  Attributes:
8160 
   - success
8161 
   - ex
8162 
  """
8163 
 
8164 
  thrift_spec = (
8165 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8167 
  )
8168 
 
8169 
  def __init__(self, success=None, ex=None,):
8170 
    self.success = success
8171 
    self.ex = ex
8172 
 
8173 
  def read(self, iprot):
8174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8176 
      return
8177 
    iprot.readStructBegin()
8178 
    while True:
8179 
      (fname, ftype, fid) = iprot.readFieldBegin()
8180 
      if ftype == TType.STOP:
8181 
        break
8182 
      if fid == 0:
8183 
        if ftype == TType.LIST:
8184 
          self.success = []
4837 varun.gupt 8185 
          (_etype101, _size98) = iprot.readListBegin()
8186 
          for _i102 in xrange(_size98):
8187 
            _elem103 = Order()
8188 
            _elem103.read(iprot)
8189 
            self.success.append(_elem103)
3427 chandransh 8190 
          iprot.readListEnd()
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      elif fid == 1:
8194 
        if ftype == TType.STRUCT:
8195 
          self.ex = TransactionServiceException()
8196 
          self.ex.read(iprot)
8197 
        else:
8198 
          iprot.skip(ftype)
8199 
      else:
8200 
        iprot.skip(ftype)
8201 
      iprot.readFieldEnd()
8202 
    iprot.readStructEnd()
8203 
 
8204 
  def write(self, oprot):
8205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8207 
      return
8208 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8209 
    if self.success is not None:
3427 chandransh 8210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8212 
      for iter104 in self.success:
8213 
        iter104.write(oprot)
3427 chandransh 8214 
      oprot.writeListEnd()
8215 
      oprot.writeFieldEnd()
3431 rajveer 8216 
    if self.ex is not None:
3427 chandransh 8217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8218 
      self.ex.write(oprot)
8219 
      oprot.writeFieldEnd()
8220 
    oprot.writeFieldStop()
8221 
    oprot.writeStructEnd()
8222 
 
3431 rajveer 8223 
  def validate(self):
8224 
    return
8225 
 
8226 
 
3427 chandransh 8227 
  def __repr__(self):
8228 
    L = ['%s=%r' % (key, value)
8229 
      for key, value in self.__dict__.iteritems()]
8230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8231 
 
8232 
  def __eq__(self, other):
8233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8234 
 
8235 
  def __ne__(self, other):
8236 
    return not (self == other)
8237 
 
1382 varun.gupt 8238 
class getReturnableOrdersForCustomer_args:
8239 
  """
8240 
  Attributes:
8241 
   - customer_id
8242 
   - limit
8243 
  """
8244 
 
8245 
  thrift_spec = (
8246 
    None, # 0
8247 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8248 
    (2, TType.I64, 'limit', None, None, ), # 2
8249 
  )
8250 
 
8251 
  def __init__(self, customer_id=None, limit=None,):
8252 
    self.customer_id = customer_id
8253 
    self.limit = limit
8254 
 
8255 
  def read(self, iprot):
8256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8258 
      return
8259 
    iprot.readStructBegin()
8260 
    while True:
8261 
      (fname, ftype, fid) = iprot.readFieldBegin()
8262 
      if ftype == TType.STOP:
8263 
        break
8264 
      if fid == 1:
8265 
        if ftype == TType.I64:
8266 
          self.customer_id = iprot.readI64();
8267 
        else:
8268 
          iprot.skip(ftype)
8269 
      elif fid == 2:
8270 
        if ftype == TType.I64:
8271 
          self.limit = iprot.readI64();
8272 
        else:
8273 
          iprot.skip(ftype)
8274 
      else:
8275 
        iprot.skip(ftype)
8276 
      iprot.readFieldEnd()
8277 
    iprot.readStructEnd()
8278 
 
8279 
  def write(self, oprot):
8280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8282 
      return
8283 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8284 
    if self.customer_id is not None:
1382 varun.gupt 8285 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8286 
      oprot.writeI64(self.customer_id)
8287 
      oprot.writeFieldEnd()
3431 rajveer 8288 
    if self.limit is not None:
1382 varun.gupt 8289 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8290 
      oprot.writeI64(self.limit)
8291 
      oprot.writeFieldEnd()
8292 
    oprot.writeFieldStop()
8293 
    oprot.writeStructEnd()
8294 
 
3431 rajveer 8295 
  def validate(self):
8296 
    return
8297 
 
8298 
 
1382 varun.gupt 8299 
  def __repr__(self):
8300 
    L = ['%s=%r' % (key, value)
8301 
      for key, value in self.__dict__.iteritems()]
8302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8303 
 
8304 
  def __eq__(self, other):
8305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8306 
 
8307 
  def __ne__(self, other):
8308 
    return not (self == other)
8309 
 
8310 
class getReturnableOrdersForCustomer_result:
8311 
  """
8312 
  Attributes:
8313 
   - success
8314 
   - ex
8315 
  """
8316 
 
8317 
  thrift_spec = (
8318 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8320 
  )
8321 
 
8322 
  def __init__(self, success=None, ex=None,):
8323 
    self.success = success
8324 
    self.ex = ex
8325 
 
8326 
  def read(self, iprot):
8327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8329 
      return
8330 
    iprot.readStructBegin()
8331 
    while True:
8332 
      (fname, ftype, fid) = iprot.readFieldBegin()
8333 
      if ftype == TType.STOP:
8334 
        break
8335 
      if fid == 0:
8336 
        if ftype == TType.LIST:
8337 
          self.success = []
4837 varun.gupt 8338 
          (_etype108, _size105) = iprot.readListBegin()
8339 
          for _i109 in xrange(_size105):
8340 
            _elem110 = iprot.readI64();
8341 
            self.success.append(_elem110)
1382 varun.gupt 8342 
          iprot.readListEnd()
8343 
        else:
8344 
          iprot.skip(ftype)
8345 
      elif fid == 1:
8346 
        if ftype == TType.STRUCT:
8347 
          self.ex = TransactionServiceException()
8348 
          self.ex.read(iprot)
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
8360 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8361 
    if self.success is not None:
1382 varun.gupt 8362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8363 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 8364 
      for iter111 in self.success:
8365 
        oprot.writeI64(iter111)
1382 varun.gupt 8366 
      oprot.writeListEnd()
8367 
      oprot.writeFieldEnd()
3431 rajveer 8368 
    if self.ex is not None:
1382 varun.gupt 8369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8370 
      self.ex.write(oprot)
8371 
      oprot.writeFieldEnd()
8372 
    oprot.writeFieldStop()
8373 
    oprot.writeStructEnd()
8374 
 
3431 rajveer 8375 
  def validate(self):
8376 
    return
8377 
 
8378 
 
1382 varun.gupt 8379 
  def __repr__(self):
8380 
    L = ['%s=%r' % (key, value)
8381 
      for key, value in self.__dict__.iteritems()]
8382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8383 
 
8384 
  def __eq__(self, other):
8385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8386 
 
8387 
  def __ne__(self, other):
8388 
    return not (self == other)
8389 
 
8390 
class getCancellableOrdersForCustomer_args:
8391 
  """
8392 
  Attributes:
8393 
   - customer_id
8394 
   - limit
8395 
  """
8396 
 
8397 
  thrift_spec = (
8398 
    None, # 0
8399 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8400 
    (2, TType.I64, 'limit', None, None, ), # 2
8401 
  )
8402 
 
8403 
  def __init__(self, customer_id=None, limit=None,):
8404 
    self.customer_id = customer_id
8405 
    self.limit = limit
8406 
 
8407 
  def read(self, iprot):
8408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8410 
      return
8411 
    iprot.readStructBegin()
8412 
    while True:
8413 
      (fname, ftype, fid) = iprot.readFieldBegin()
8414 
      if ftype == TType.STOP:
8415 
        break
8416 
      if fid == 1:
8417 
        if ftype == TType.I64:
8418 
          self.customer_id = iprot.readI64();
8419 
        else:
8420 
          iprot.skip(ftype)
8421 
      elif fid == 2:
8422 
        if ftype == TType.I64:
8423 
          self.limit = iprot.readI64();
8424 
        else:
8425 
          iprot.skip(ftype)
8426 
      else:
8427 
        iprot.skip(ftype)
8428 
      iprot.readFieldEnd()
8429 
    iprot.readStructEnd()
8430 
 
8431 
  def write(self, oprot):
8432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8434 
      return
8435 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8436 
    if self.customer_id is not None:
1382 varun.gupt 8437 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8438 
      oprot.writeI64(self.customer_id)
8439 
      oprot.writeFieldEnd()
3431 rajveer 8440 
    if self.limit is not None:
1382 varun.gupt 8441 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8442 
      oprot.writeI64(self.limit)
8443 
      oprot.writeFieldEnd()
8444 
    oprot.writeFieldStop()
8445 
    oprot.writeStructEnd()
8446 
 
3431 rajveer 8447 
  def validate(self):
8448 
    return
8449 
 
8450 
 
1382 varun.gupt 8451 
  def __repr__(self):
8452 
    L = ['%s=%r' % (key, value)
8453 
      for key, value in self.__dict__.iteritems()]
8454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8455 
 
8456 
  def __eq__(self, other):
8457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8458 
 
8459 
  def __ne__(self, other):
8460 
    return not (self == other)
8461 
 
8462 
class getCancellableOrdersForCustomer_result:
8463 
  """
8464 
  Attributes:
8465 
   - success
8466 
   - ex
8467 
  """
8468 
 
8469 
  thrift_spec = (
8470 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8472 
  )
8473 
 
8474 
  def __init__(self, success=None, ex=None,):
8475 
    self.success = success
8476 
    self.ex = ex
8477 
 
8478 
  def read(self, iprot):
8479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8481 
      return
8482 
    iprot.readStructBegin()
8483 
    while True:
8484 
      (fname, ftype, fid) = iprot.readFieldBegin()
8485 
      if ftype == TType.STOP:
8486 
        break
8487 
      if fid == 0:
8488 
        if ftype == TType.LIST:
8489 
          self.success = []
4837 varun.gupt 8490 
          (_etype115, _size112) = iprot.readListBegin()
8491 
          for _i116 in xrange(_size112):
8492 
            _elem117 = iprot.readI64();
8493 
            self.success.append(_elem117)
1382 varun.gupt 8494 
          iprot.readListEnd()
8495 
        else:
8496 
          iprot.skip(ftype)
8497 
      elif fid == 1:
8498 
        if ftype == TType.STRUCT:
8499 
          self.ex = TransactionServiceException()
8500 
          self.ex.read(iprot)
8501 
        else:
8502 
          iprot.skip(ftype)
8503 
      else:
8504 
        iprot.skip(ftype)
8505 
      iprot.readFieldEnd()
8506 
    iprot.readStructEnd()
8507 
 
8508 
  def write(self, oprot):
8509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8511 
      return
8512 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8513 
    if self.success is not None:
1382 varun.gupt 8514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8515 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 8516 
      for iter118 in self.success:
8517 
        oprot.writeI64(iter118)
1382 varun.gupt 8518 
      oprot.writeListEnd()
8519 
      oprot.writeFieldEnd()
3431 rajveer 8520 
    if self.ex is not None:
1382 varun.gupt 8521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8522 
      self.ex.write(oprot)
8523 
      oprot.writeFieldEnd()
8524 
    oprot.writeFieldStop()
8525 
    oprot.writeStructEnd()
8526 
 
3431 rajveer 8527 
  def validate(self):
8528 
    return
8529 
 
8530 
 
1382 varun.gupt 8531 
  def __repr__(self):
8532 
    L = ['%s=%r' % (key, value)
8533 
      for key, value in self.__dict__.iteritems()]
8534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8535 
 
8536 
  def __eq__(self, other):
8537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8538 
 
8539 
  def __ne__(self, other):
8540 
    return not (self == other)
8541 
 
483 rajveer 8542 
class changeOrderStatus_args:
94 ashish 8543 
  """
8544 
  Attributes:
483 rajveer 8545 
   - orderId
8546 
   - status
8547 
   - description
94 ashish 8548 
  """
8549 
 
8550 
  thrift_spec = (
8551 
    None, # 0
483 rajveer 8552 
    (1, TType.I64, 'orderId', None, None, ), # 1
8553 
    (2, TType.I32, 'status', None, None, ), # 2
8554 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8555 
  )
8556 
 
483 rajveer 8557 
  def __init__(self, orderId=None, status=None, description=None,):
8558 
    self.orderId = orderId
8559 
    self.status = status
8560 
    self.description = description
94 ashish 8561 
 
8562 
  def read(self, iprot):
8563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8565 
      return
8566 
    iprot.readStructBegin()
8567 
    while True:
8568 
      (fname, ftype, fid) = iprot.readFieldBegin()
8569 
      if ftype == TType.STOP:
8570 
        break
8571 
      if fid == 1:
8572 
        if ftype == TType.I64:
483 rajveer 8573 
          self.orderId = iprot.readI64();
94 ashish 8574 
        else:
8575 
          iprot.skip(ftype)
8576 
      elif fid == 2:
483 rajveer 8577 
        if ftype == TType.I32:
8578 
          self.status = iprot.readI32();
94 ashish 8579 
        else:
8580 
          iprot.skip(ftype)
483 rajveer 8581 
      elif fid == 3:
8582 
        if ftype == TType.STRING:
8583 
          self.description = iprot.readString();
8584 
        else:
8585 
          iprot.skip(ftype)
94 ashish 8586 
      else:
8587 
        iprot.skip(ftype)
8588 
      iprot.readFieldEnd()
8589 
    iprot.readStructEnd()
8590 
 
8591 
  def write(self, oprot):
8592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8594 
      return
483 rajveer 8595 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8596 
    if self.orderId is not None:
483 rajveer 8597 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8598 
      oprot.writeI64(self.orderId)
94 ashish 8599 
      oprot.writeFieldEnd()
3431 rajveer 8600 
    if self.status is not None:
483 rajveer 8601 
      oprot.writeFieldBegin('status', TType.I32, 2)
8602 
      oprot.writeI32(self.status)
94 ashish 8603 
      oprot.writeFieldEnd()
3431 rajveer 8604 
    if self.description is not None:
483 rajveer 8605 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8606 
      oprot.writeString(self.description)
8607 
      oprot.writeFieldEnd()
94 ashish 8608 
    oprot.writeFieldStop()
8609 
    oprot.writeStructEnd()
8610 
 
3431 rajveer 8611 
  def validate(self):
8612 
    return
8613 
 
8614 
 
94 ashish 8615 
  def __repr__(self):
8616 
    L = ['%s=%r' % (key, value)
8617 
      for key, value in self.__dict__.iteritems()]
8618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8619 
 
8620 
  def __eq__(self, other):
8621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8622 
 
8623 
  def __ne__(self, other):
8624 
    return not (self == other)
8625 
 
483 rajveer 8626 
class changeOrderStatus_result:
94 ashish 8627 
  """
8628 
  Attributes:
8629 
   - success
8630 
   - ex
8631 
  """
8632 
 
8633 
  thrift_spec = (
8634 
    (0, TType.BOOL, 'success', None, None, ), # 0
8635 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8636 
  )
8637 
 
8638 
  def __init__(self, success=None, ex=None,):
8639 
    self.success = success
8640 
    self.ex = ex
8641 
 
8642 
  def read(self, iprot):
8643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8645 
      return
8646 
    iprot.readStructBegin()
8647 
    while True:
8648 
      (fname, ftype, fid) = iprot.readFieldBegin()
8649 
      if ftype == TType.STOP:
8650 
        break
8651 
      if fid == 0:
8652 
        if ftype == TType.BOOL:
8653 
          self.success = iprot.readBool();
8654 
        else:
8655 
          iprot.skip(ftype)
8656 
      elif fid == 1:
8657 
        if ftype == TType.STRUCT:
8658 
          self.ex = TransactionServiceException()
8659 
          self.ex.read(iprot)
8660 
        else:
8661 
          iprot.skip(ftype)
8662 
      else:
8663 
        iprot.skip(ftype)
8664 
      iprot.readFieldEnd()
8665 
    iprot.readStructEnd()
8666 
 
8667 
  def write(self, oprot):
8668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8670 
      return
483 rajveer 8671 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8672 
    if self.success is not None:
94 ashish 8673 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8674 
      oprot.writeBool(self.success)
8675 
      oprot.writeFieldEnd()
3431 rajveer 8676 
    if self.ex is not None:
94 ashish 8677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8678 
      self.ex.write(oprot)
8679 
      oprot.writeFieldEnd()
8680 
    oprot.writeFieldStop()
8681 
    oprot.writeStructEnd()
8682 
 
3431 rajveer 8683 
  def validate(self):
8684 
    return
8685 
 
8686 
 
94 ashish 8687 
  def __repr__(self):
8688 
    L = ['%s=%r' % (key, value)
8689 
      for key, value in self.__dict__.iteritems()]
8690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8691 
 
8692 
  def __eq__(self, other):
8693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8694 
 
8695 
  def __ne__(self, other):
8696 
    return not (self == other)
8697 
 
3064 chandransh 8698 
class getOrdersForTransaction_args:
494 rajveer 8699 
  """
8700 
  Attributes:
3064 chandransh 8701 
   - transactionId
8702 
   - customerId
494 rajveer 8703 
  """
8704 
 
8705 
  thrift_spec = (
8706 
    None, # 0
3064 chandransh 8707 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8708 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8709 
  )
8710 
 
3064 chandransh 8711 
  def __init__(self, transactionId=None, customerId=None,):
8712 
    self.transactionId = transactionId
8713 
    self.customerId = customerId
494 rajveer 8714 
 
8715 
  def read(self, iprot):
8716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8718 
      return
8719 
    iprot.readStructBegin()
8720 
    while True:
8721 
      (fname, ftype, fid) = iprot.readFieldBegin()
8722 
      if ftype == TType.STOP:
8723 
        break
8724 
      if fid == 1:
8725 
        if ftype == TType.I64:
3064 chandransh 8726 
          self.transactionId = iprot.readI64();
494 rajveer 8727 
        else:
8728 
          iprot.skip(ftype)
8729 
      elif fid == 2:
3064 chandransh 8730 
        if ftype == TType.I64:
8731 
          self.customerId = iprot.readI64();
494 rajveer 8732 
        else:
8733 
          iprot.skip(ftype)
8734 
      else:
8735 
        iprot.skip(ftype)
8736 
      iprot.readFieldEnd()
8737 
    iprot.readStructEnd()
8738 
 
8739 
  def write(self, oprot):
8740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8742 
      return
3064 chandransh 8743 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8744 
    if self.transactionId is not None:
3064 chandransh 8745 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8746 
      oprot.writeI64(self.transactionId)
494 rajveer 8747 
      oprot.writeFieldEnd()
3431 rajveer 8748 
    if self.customerId is not None:
3064 chandransh 8749 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8750 
      oprot.writeI64(self.customerId)
494 rajveer 8751 
      oprot.writeFieldEnd()
8752 
    oprot.writeFieldStop()
8753 
    oprot.writeStructEnd()
8754 
 
3431 rajveer 8755 
  def validate(self):
8756 
    return
8757 
 
8758 
 
494 rajveer 8759 
  def __repr__(self):
8760 
    L = ['%s=%r' % (key, value)
8761 
      for key, value in self.__dict__.iteritems()]
8762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8763 
 
8764 
  def __eq__(self, other):
8765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8766 
 
8767 
  def __ne__(self, other):
8768 
    return not (self == other)
8769 
 
3064 chandransh 8770 
class getOrdersForTransaction_result:
494 rajveer 8771 
  """
8772 
  Attributes:
8773 
   - success
8774 
   - ex
8775 
  """
8776 
 
8777 
  thrift_spec = (
3064 chandransh 8778 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8780 
  )
8781 
 
8782 
  def __init__(self, success=None, ex=None,):
8783 
    self.success = success
8784 
    self.ex = ex
8785 
 
8786 
  def read(self, iprot):
8787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8789 
      return
8790 
    iprot.readStructBegin()
8791 
    while True:
8792 
      (fname, ftype, fid) = iprot.readFieldBegin()
8793 
      if ftype == TType.STOP:
8794 
        break
8795 
      if fid == 0:
3064 chandransh 8796 
        if ftype == TType.LIST:
8797 
          self.success = []
4837 varun.gupt 8798 
          (_etype122, _size119) = iprot.readListBegin()
8799 
          for _i123 in xrange(_size119):
8800 
            _elem124 = Order()
8801 
            _elem124.read(iprot)
8802 
            self.success.append(_elem124)
3064 chandransh 8803 
          iprot.readListEnd()
494 rajveer 8804 
        else:
8805 
          iprot.skip(ftype)
8806 
      elif fid == 1:
8807 
        if ftype == TType.STRUCT:
8808 
          self.ex = TransactionServiceException()
8809 
          self.ex.read(iprot)
8810 
        else:
8811 
          iprot.skip(ftype)
8812 
      else:
8813 
        iprot.skip(ftype)
8814 
      iprot.readFieldEnd()
8815 
    iprot.readStructEnd()
8816 
 
8817 
  def write(self, oprot):
8818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8820 
      return
3064 chandransh 8821 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8822 
    if self.success is not None:
3064 chandransh 8823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8825 
      for iter125 in self.success:
8826 
        iter125.write(oprot)
3064 chandransh 8827 
      oprot.writeListEnd()
494 rajveer 8828 
      oprot.writeFieldEnd()
3431 rajveer 8829 
    if self.ex is not None:
494 rajveer 8830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8831 
      self.ex.write(oprot)
8832 
      oprot.writeFieldEnd()
8833 
    oprot.writeFieldStop()
8834 
    oprot.writeStructEnd()
8835 
 
3431 rajveer 8836 
  def validate(self):
8837 
    return
8838 
 
8839 
 
494 rajveer 8840 
  def __repr__(self):
8841 
    L = ['%s=%r' % (key, value)
8842 
      for key, value in self.__dict__.iteritems()]
8843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8844 
 
8845 
  def __eq__(self, other):
8846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8847 
 
8848 
  def __ne__(self, other):
8849 
    return not (self == other)
8850 
 
3064 chandransh 8851 
class getOrdersForCustomer_args:
1149 chandransh 8852 
  """
8853 
  Attributes:
3064 chandransh 8854 
   - customerId
8855 
   - from_date
8856 
   - to_date
8857 
   - statuses
1149 chandransh 8858 
  """
8859 
 
8860 
  thrift_spec = (
8861 
    None, # 0
3064 chandransh 8862 
    (1, TType.I64, 'customerId', None, None, ), # 1
8863 
    (2, TType.I64, 'from_date', None, None, ), # 2
8864 
    (3, TType.I64, 'to_date', None, None, ), # 3
8865 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8866 
  )
8867 
 
3064 chandransh 8868 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8869 
    self.customerId = customerId
8870 
    self.from_date = from_date
8871 
    self.to_date = to_date
8872 
    self.statuses = statuses
1149 chandransh 8873 
 
8874 
  def read(self, iprot):
8875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8877 
      return
8878 
    iprot.readStructBegin()
8879 
    while True:
8880 
      (fname, ftype, fid) = iprot.readFieldBegin()
8881 
      if ftype == TType.STOP:
8882 
        break
8883 
      if fid == 1:
8884 
        if ftype == TType.I64:
3064 chandransh 8885 
          self.customerId = iprot.readI64();
1149 chandransh 8886 
        else:
8887 
          iprot.skip(ftype)
8888 
      elif fid == 2:
8889 
        if ftype == TType.I64:
3064 chandransh 8890 
          self.from_date = iprot.readI64();
1149 chandransh 8891 
        else:
8892 
          iprot.skip(ftype)
2783 chandransh 8893 
      elif fid == 3:
8894 
        if ftype == TType.I64:
3064 chandransh 8895 
          self.to_date = iprot.readI64();
2783 chandransh 8896 
        else:
8897 
          iprot.skip(ftype)
8898 
      elif fid == 4:
3064 chandransh 8899 
        if ftype == TType.LIST:
8900 
          self.statuses = []
4837 varun.gupt 8901 
          (_etype129, _size126) = iprot.readListBegin()
8902 
          for _i130 in xrange(_size126):
8903 
            _elem131 = iprot.readI32();
8904 
            self.statuses.append(_elem131)
3064 chandransh 8905 
          iprot.readListEnd()
2783 chandransh 8906 
        else:
8907 
          iprot.skip(ftype)
1149 chandransh 8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
3064 chandransh 8917 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8918 
    if self.customerId is not None:
3064 chandransh 8919 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8920 
      oprot.writeI64(self.customerId)
1149 chandransh 8921 
      oprot.writeFieldEnd()
3431 rajveer 8922 
    if self.from_date is not None:
3064 chandransh 8923 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8924 
      oprot.writeI64(self.from_date)
1149 chandransh 8925 
      oprot.writeFieldEnd()
3431 rajveer 8926 
    if self.to_date is not None:
3064 chandransh 8927 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8928 
      oprot.writeI64(self.to_date)
2783 chandransh 8929 
      oprot.writeFieldEnd()
3431 rajveer 8930 
    if self.statuses is not None:
3064 chandransh 8931 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8932 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 8933 
      for iter132 in self.statuses:
8934 
        oprot.writeI32(iter132)
3064 chandransh 8935 
      oprot.writeListEnd()
2783 chandransh 8936 
      oprot.writeFieldEnd()
1149 chandransh 8937 
    oprot.writeFieldStop()
8938 
    oprot.writeStructEnd()
8939 
 
3431 rajveer 8940 
  def validate(self):
8941 
    return
8942 
 
8943 
 
1149 chandransh 8944 
  def __repr__(self):
8945 
    L = ['%s=%r' % (key, value)
8946 
      for key, value in self.__dict__.iteritems()]
8947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8948 
 
8949 
  def __eq__(self, other):
8950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8951 
 
8952 
  def __ne__(self, other):
8953 
    return not (self == other)
8954 
 
3064 chandransh 8955 
class getOrdersForCustomer_result:
1149 chandransh 8956 
  """
8957 
  Attributes:
8958 
   - success
8959 
   - ex
8960 
  """
8961 
 
8962 
  thrift_spec = (
3064 chandransh 8963 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8965 
  )
8966 
 
8967 
  def __init__(self, success=None, ex=None,):
8968 
    self.success = success
8969 
    self.ex = ex
8970 
 
8971 
  def read(self, iprot):
8972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8974 
      return
8975 
    iprot.readStructBegin()
8976 
    while True:
8977 
      (fname, ftype, fid) = iprot.readFieldBegin()
8978 
      if ftype == TType.STOP:
8979 
        break
8980 
      if fid == 0:
3064 chandransh 8981 
        if ftype == TType.LIST:
8982 
          self.success = []
4837 varun.gupt 8983 
          (_etype136, _size133) = iprot.readListBegin()
8984 
          for _i137 in xrange(_size133):
8985 
            _elem138 = Order()
8986 
            _elem138.read(iprot)
8987 
            self.success.append(_elem138)
3064 chandransh 8988 
          iprot.readListEnd()
1149 chandransh 8989 
        else:
8990 
          iprot.skip(ftype)
8991 
      elif fid == 1:
8992 
        if ftype == TType.STRUCT:
8993 
          self.ex = TransactionServiceException()
8994 
          self.ex.read(iprot)
8995 
        else:
8996 
          iprot.skip(ftype)
8997 
      else:
8998 
        iprot.skip(ftype)
8999 
      iprot.readFieldEnd()
9000 
    iprot.readStructEnd()
9001 
 
9002 
  def write(self, oprot):
9003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9005 
      return
3064 chandransh 9006 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9007 
    if self.success is not None:
3064 chandransh 9008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9010 
      for iter139 in self.success:
9011 
        iter139.write(oprot)
3064 chandransh 9012 
      oprot.writeListEnd()
1149 chandransh 9013 
      oprot.writeFieldEnd()
3431 rajveer 9014 
    if self.ex is not None:
1149 chandransh 9015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9016 
      self.ex.write(oprot)
9017 
      oprot.writeFieldEnd()
9018 
    oprot.writeFieldStop()
9019 
    oprot.writeStructEnd()
9020 
 
3431 rajveer 9021 
  def validate(self):
9022 
    return
9023 
 
9024 
 
1149 chandransh 9025 
  def __repr__(self):
9026 
    L = ['%s=%r' % (key, value)
9027 
      for key, value in self.__dict__.iteritems()]
9028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9029 
 
9030 
  def __eq__(self, other):
9031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9032 
 
9033 
  def __ne__(self, other):
9034 
    return not (self == other)
9035 
 
3064 chandransh 9036 
class createOrder_args:
921 rajveer 9037 
  """
9038 
  Attributes:
3064 chandransh 9039 
   - order
921 rajveer 9040 
  """
9041 
 
9042 
  thrift_spec = (
9043 
    None, # 0
3064 chandransh 9044 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9045 
  )
9046 
 
3064 chandransh 9047 
  def __init__(self, order=None,):
9048 
    self.order = order
921 rajveer 9049 
 
9050 
  def read(self, iprot):
9051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9053 
      return
9054 
    iprot.readStructBegin()
9055 
    while True:
9056 
      (fname, ftype, fid) = iprot.readFieldBegin()
9057 
      if ftype == TType.STOP:
9058 
        break
9059 
      if fid == 1:
3064 chandransh 9060 
        if ftype == TType.STRUCT:
9061 
          self.order = Order()
9062 
          self.order.read(iprot)
921 rajveer 9063 
        else:
9064 
          iprot.skip(ftype)
9065 
      else:
9066 
        iprot.skip(ftype)
9067 
      iprot.readFieldEnd()
9068 
    iprot.readStructEnd()
9069 
 
9070 
  def write(self, oprot):
9071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9073 
      return
3064 chandransh 9074 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9075 
    if self.order is not None:
3064 chandransh 9076 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9077 
      self.order.write(oprot)
921 rajveer 9078 
      oprot.writeFieldEnd()
9079 
    oprot.writeFieldStop()
9080 
    oprot.writeStructEnd()
9081 
 
3431 rajveer 9082 
  def validate(self):
9083 
    return
9084 
 
9085 
 
921 rajveer 9086 
  def __repr__(self):
9087 
    L = ['%s=%r' % (key, value)
9088 
      for key, value in self.__dict__.iteritems()]
9089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9090 
 
9091 
  def __eq__(self, other):
9092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9093 
 
9094 
  def __ne__(self, other):
9095 
    return not (self == other)
9096 
 
3064 chandransh 9097 
class createOrder_result:
921 rajveer 9098 
  """
9099 
  Attributes:
9100 
   - success
9101 
   - ex
9102 
  """
9103 
 
9104 
  thrift_spec = (
3064 chandransh 9105 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9107 
  )
9108 
 
9109 
  def __init__(self, success=None, ex=None,):
9110 
    self.success = success
9111 
    self.ex = ex
9112 
 
9113 
  def read(self, iprot):
9114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9116 
      return
9117 
    iprot.readStructBegin()
9118 
    while True:
9119 
      (fname, ftype, fid) = iprot.readFieldBegin()
9120 
      if ftype == TType.STOP:
9121 
        break
9122 
      if fid == 0:
3064 chandransh 9123 
        if ftype == TType.I64:
9124 
          self.success = iprot.readI64();
921 rajveer 9125 
        else:
9126 
          iprot.skip(ftype)
9127 
      elif fid == 1:
9128 
        if ftype == TType.STRUCT:
9129 
          self.ex = TransactionServiceException()
9130 
          self.ex.read(iprot)
9131 
        else:
9132 
          iprot.skip(ftype)
9133 
      else:
9134 
        iprot.skip(ftype)
9135 
      iprot.readFieldEnd()
9136 
    iprot.readStructEnd()
9137 
 
9138 
  def write(self, oprot):
9139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9141 
      return
3064 chandransh 9142 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9143 
    if self.success is not None:
3064 chandransh 9144 
      oprot.writeFieldBegin('success', TType.I64, 0)
9145 
      oprot.writeI64(self.success)
921 rajveer 9146 
      oprot.writeFieldEnd()
3431 rajveer 9147 
    if self.ex is not None:
921 rajveer 9148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9149 
      self.ex.write(oprot)
9150 
      oprot.writeFieldEnd()
9151 
    oprot.writeFieldStop()
9152 
    oprot.writeStructEnd()
9153 
 
3431 rajveer 9154 
  def validate(self):
9155 
    return
9156 
 
9157 
 
921 rajveer 9158 
  def __repr__(self):
9159 
    L = ['%s=%r' % (key, value)
9160 
      for key, value in self.__dict__.iteritems()]
9161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9162 
 
9163 
  def __eq__(self, other):
9164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9165 
 
9166 
  def __ne__(self, other):
9167 
    return not (self == other)
9168 
 
3064 chandransh 9169 
class getOrder_args:
921 rajveer 9170 
  """
9171 
  Attributes:
3064 chandransh 9172 
   - id
921 rajveer 9173 
  """
9174 
 
9175 
  thrift_spec = (
9176 
    None, # 0
3064 chandransh 9177 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9178 
  )
9179 
 
3064 chandransh 9180 
  def __init__(self, id=None,):
9181 
    self.id = id
921 rajveer 9182 
 
9183 
  def read(self, iprot):
9184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9186 
      return
9187 
    iprot.readStructBegin()
9188 
    while True:
9189 
      (fname, ftype, fid) = iprot.readFieldBegin()
9190 
      if ftype == TType.STOP:
9191 
        break
9192 
      if fid == 1:
9193 
        if ftype == TType.I64:
3064 chandransh 9194 
          self.id = iprot.readI64();
921 rajveer 9195 
        else:
9196 
          iprot.skip(ftype)
9197 
      else:
9198 
        iprot.skip(ftype)
9199 
      iprot.readFieldEnd()
9200 
    iprot.readStructEnd()
9201 
 
9202 
  def write(self, oprot):
9203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9205 
      return
3064 chandransh 9206 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9207 
    if self.id is not None:
3064 chandransh 9208 
      oprot.writeFieldBegin('id', TType.I64, 1)
9209 
      oprot.writeI64(self.id)
921 rajveer 9210 
      oprot.writeFieldEnd()
9211 
    oprot.writeFieldStop()
9212 
    oprot.writeStructEnd()
9213 
 
3431 rajveer 9214 
  def validate(self):
9215 
    return
9216 
 
9217 
 
921 rajveer 9218 
  def __repr__(self):
9219 
    L = ['%s=%r' % (key, value)
9220 
      for key, value in self.__dict__.iteritems()]
9221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9222 
 
9223 
  def __eq__(self, other):
9224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9225 
 
9226 
  def __ne__(self, other):
9227 
    return not (self == other)
9228 
 
3064 chandransh 9229 
class getOrder_result:
921 rajveer 9230 
  """
9231 
  Attributes:
9232 
   - success
9233 
   - ex
9234 
  """
9235 
 
9236 
  thrift_spec = (
3064 chandransh 9237 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9239 
  )
9240 
 
9241 
  def __init__(self, success=None, ex=None,):
9242 
    self.success = success
9243 
    self.ex = ex
9244 
 
9245 
  def read(self, iprot):
9246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9248 
      return
9249 
    iprot.readStructBegin()
9250 
    while True:
9251 
      (fname, ftype, fid) = iprot.readFieldBegin()
9252 
      if ftype == TType.STOP:
9253 
        break
9254 
      if fid == 0:
3064 chandransh 9255 
        if ftype == TType.STRUCT:
9256 
          self.success = Order()
9257 
          self.success.read(iprot)
921 rajveer 9258 
        else:
9259 
          iprot.skip(ftype)
9260 
      elif fid == 1:
9261 
        if ftype == TType.STRUCT:
9262 
          self.ex = TransactionServiceException()
9263 
          self.ex.read(iprot)
9264 
        else:
9265 
          iprot.skip(ftype)
9266 
      else:
9267 
        iprot.skip(ftype)
9268 
      iprot.readFieldEnd()
9269 
    iprot.readStructEnd()
9270 
 
9271 
  def write(self, oprot):
9272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9274 
      return
3064 chandransh 9275 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9276 
    if self.success is not None:
3064 chandransh 9277 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9278 
      self.success.write(oprot)
921 rajveer 9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.ex is not None:
921 rajveer 9281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9282 
      self.ex.write(oprot)
9283 
      oprot.writeFieldEnd()
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
921 rajveer 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
3064 chandransh 9302 
class getLineItemsForOrder_args:
94 ashish 9303 
  """
9304 
  Attributes:
3064 chandransh 9305 
   - orderId
94 ashish 9306 
  """
9307 
 
9308 
  thrift_spec = (
9309 
    None, # 0
3064 chandransh 9310 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9311 
  )
9312 
 
3064 chandransh 9313 
  def __init__(self, orderId=None,):
9314 
    self.orderId = orderId
94 ashish 9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 1:
9326 
        if ftype == TType.I64:
3064 chandransh 9327 
          self.orderId = iprot.readI64();
94 ashish 9328 
        else:
9329 
          iprot.skip(ftype)
9330 
      else:
9331 
        iprot.skip(ftype)
9332 
      iprot.readFieldEnd()
9333 
    iprot.readStructEnd()
9334 
 
9335 
  def write(self, oprot):
9336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9338 
      return
3064 chandransh 9339 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9340 
    if self.orderId is not None:
3064 chandransh 9341 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9342 
      oprot.writeI64(self.orderId)
94 ashish 9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
3431 rajveer 9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
94 ashish 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 
 
3064 chandransh 9362 
class getLineItemsForOrder_result:
94 ashish 9363 
  """
9364 
  Attributes:
9365 
   - success
9366 
   - ex
9367 
  """
9368 
 
9369 
  thrift_spec = (
3064 chandransh 9370 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 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:
483 rajveer 9388 
        if ftype == TType.LIST:
9389 
          self.success = []
4837 varun.gupt 9390 
          (_etype143, _size140) = iprot.readListBegin()
9391 
          for _i144 in xrange(_size140):
9392 
            _elem145 = LineItem()
9393 
            _elem145.read(iprot)
9394 
            self.success.append(_elem145)
483 rajveer 9395 
          iprot.readListEnd()
94 ashish 9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      elif fid == 1:
9399 
        if ftype == TType.STRUCT:
9400 
          self.ex = TransactionServiceException()
9401 
          self.ex.read(iprot)
9402 
        else:
9403 
          iprot.skip(ftype)
9404 
      else:
9405 
        iprot.skip(ftype)
9406 
      iprot.readFieldEnd()
9407 
    iprot.readStructEnd()
9408 
 
9409 
  def write(self, oprot):
9410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9412 
      return
3064 chandransh 9413 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9414 
    if self.success is not None:
483 rajveer 9415 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9416 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9417 
      for iter146 in self.success:
9418 
        iter146.write(oprot)
483 rajveer 9419 
      oprot.writeListEnd()
94 ashish 9420 
      oprot.writeFieldEnd()
3431 rajveer 9421 
    if self.ex is not None:
94 ashish 9422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9423 
      self.ex.write(oprot)
9424 
      oprot.writeFieldEnd()
9425 
    oprot.writeFieldStop()
9426 
    oprot.writeStructEnd()
9427 
 
3431 rajveer 9428 
  def validate(self):
9429 
    return
9430 
 
9431 
 
94 ashish 9432 
  def __repr__(self):
9433 
    L = ['%s=%r' % (key, value)
9434 
      for key, value in self.__dict__.iteritems()]
9435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9436 
 
9437 
  def __eq__(self, other):
9438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9439 
 
9440 
  def __ne__(self, other):
9441 
    return not (self == other)
9442 
 
3064 chandransh 9443 
class getOrderForCustomer_args:
94 ashish 9444 
  """
9445 
  Attributes:
3064 chandransh 9446 
   - orderId
483 rajveer 9447 
   - customerId
94 ashish 9448 
  """
9449 
 
9450 
  thrift_spec = (
9451 
    None, # 0
3064 chandransh 9452 
    (1, TType.I64, 'orderId', None, None, ), # 1
9453 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9454 
  )
9455 
 
3064 chandransh 9456 
  def __init__(self, orderId=None, customerId=None,):
9457 
    self.orderId = orderId
483 rajveer 9458 
    self.customerId = customerId
94 ashish 9459 
 
9460 
  def read(self, iprot):
9461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9463 
      return
9464 
    iprot.readStructBegin()
9465 
    while True:
9466 
      (fname, ftype, fid) = iprot.readFieldBegin()
9467 
      if ftype == TType.STOP:
9468 
        break
9469 
      if fid == 1:
9470 
        if ftype == TType.I64:
3064 chandransh 9471 
          self.orderId = iprot.readI64();
94 ashish 9472 
        else:
9473 
          iprot.skip(ftype)
9474 
      elif fid == 2:
9475 
        if ftype == TType.I64:
3064 chandransh 9476 
          self.customerId = iprot.readI64();
94 ashish 9477 
        else:
9478 
          iprot.skip(ftype)
9479 
      else:
9480 
        iprot.skip(ftype)
9481 
      iprot.readFieldEnd()
9482 
    iprot.readStructEnd()
9483 
 
9484 
  def write(self, oprot):
9485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9487 
      return
3064 chandransh 9488 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9489 
    if self.orderId is not None:
3064 chandransh 9490 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9491 
      oprot.writeI64(self.orderId)
9492 
      oprot.writeFieldEnd()
3431 rajveer 9493 
    if self.customerId is not None:
3064 chandransh 9494 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9495 
      oprot.writeI64(self.customerId)
94 ashish 9496 
      oprot.writeFieldEnd()
9497 
    oprot.writeFieldStop()
9498 
    oprot.writeStructEnd()
9499 
 
3431 rajveer 9500 
  def validate(self):
9501 
    return
9502 
 
9503 
 
94 ashish 9504 
  def __repr__(self):
9505 
    L = ['%s=%r' % (key, value)
9506 
      for key, value in self.__dict__.iteritems()]
9507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9508 
 
9509 
  def __eq__(self, other):
9510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9511 
 
9512 
  def __ne__(self, other):
9513 
    return not (self == other)
9514 
 
3064 chandransh 9515 
class getOrderForCustomer_result:
94 ashish 9516 
  """
9517 
  Attributes:
9518 
   - success
9519 
   - ex
9520 
  """
9521 
 
9522 
  thrift_spec = (
3064 chandransh 9523 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9525 
  )
9526 
 
9527 
  def __init__(self, success=None, ex=None,):
9528 
    self.success = success
9529 
    self.ex = ex
9530 
 
9531 
  def read(self, iprot):
9532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9534 
      return
9535 
    iprot.readStructBegin()
9536 
    while True:
9537 
      (fname, ftype, fid) = iprot.readFieldBegin()
9538 
      if ftype == TType.STOP:
9539 
        break
9540 
      if fid == 0:
3064 chandransh 9541 
        if ftype == TType.STRUCT:
9542 
          self.success = Order()
9543 
          self.success.read(iprot)
94 ashish 9544 
        else:
9545 
          iprot.skip(ftype)
9546 
      elif fid == 1:
9547 
        if ftype == TType.STRUCT:
9548 
          self.ex = TransactionServiceException()
9549 
          self.ex.read(iprot)
9550 
        else:
9551 
          iprot.skip(ftype)
9552 
      else:
9553 
        iprot.skip(ftype)
9554 
      iprot.readFieldEnd()
9555 
    iprot.readStructEnd()
9556 
 
9557 
  def write(self, oprot):
9558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9560 
      return
3064 chandransh 9561 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9562 
    if self.success is not None:
3064 chandransh 9563 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9564 
      self.success.write(oprot)
94 ashish 9565 
      oprot.writeFieldEnd()
3431 rajveer 9566 
    if self.ex is not None:
94 ashish 9567 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9568 
      self.ex.write(oprot)
9569 
      oprot.writeFieldEnd()
9570 
    oprot.writeFieldStop()
9571 
    oprot.writeStructEnd()
9572 
 
3431 rajveer 9573 
  def validate(self):
9574 
    return
9575 
 
9576 
 
94 ashish 9577 
  def __repr__(self):
9578 
    L = ['%s=%r' % (key, value)
9579 
      for key, value in self.__dict__.iteritems()]
9580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9581 
 
9582 
  def __eq__(self, other):
9583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9584 
 
9585 
  def __ne__(self, other):
9586 
    return not (self == other)
9587 
 
3064 chandransh 9588 
class getAlerts_args:
94 ashish 9589 
  """
9590 
  Attributes:
4394 rajveer 9591 
   - type
4444 rajveer 9592 
   - warehouseId
4394 rajveer 9593 
   - status
9594 
   - timestamp
94 ashish 9595 
  """
9596 
 
9597 
  thrift_spec = (
9598 
    None, # 0
4394 rajveer 9599 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9600 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9601 
    (3, TType.I64, 'status', None, None, ), # 3
9602 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9603 
  )
9604 
 
4444 rajveer 9605 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9606 
    self.type = type
4444 rajveer 9607 
    self.warehouseId = warehouseId
4394 rajveer 9608 
    self.status = status
9609 
    self.timestamp = timestamp
94 ashish 9610 
 
9611 
  def read(self, iprot):
9612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9614 
      return
9615 
    iprot.readStructBegin()
9616 
    while True:
9617 
      (fname, ftype, fid) = iprot.readFieldBegin()
9618 
      if ftype == TType.STOP:
9619 
        break
9620 
      if fid == 1:
3064 chandransh 9621 
        if ftype == TType.I64:
4394 rajveer 9622 
          self.type = iprot.readI64();
94 ashish 9623 
        else:
9624 
          iprot.skip(ftype)
3064 chandransh 9625 
      elif fid == 2:
4394 rajveer 9626 
        if ftype == TType.I64:
4444 rajveer 9627 
          self.warehouseId = iprot.readI64();
3064 chandransh 9628 
        else:
9629 
          iprot.skip(ftype)
4394 rajveer 9630 
      elif fid == 3:
9631 
        if ftype == TType.I64:
4444 rajveer 9632 
          self.status = iprot.readI64();
9633 
        else:
9634 
          iprot.skip(ftype)
9635 
      elif fid == 4:
9636 
        if ftype == TType.I64:
4394 rajveer 9637 
          self.timestamp = iprot.readI64();
9638 
        else:
9639 
          iprot.skip(ftype)
94 ashish 9640 
      else:
9641 
        iprot.skip(ftype)
9642 
      iprot.readFieldEnd()
9643 
    iprot.readStructEnd()
9644 
 
9645 
  def write(self, oprot):
9646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9648 
      return
3064 chandransh 9649 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9650 
    if self.type is not None:
9651 
      oprot.writeFieldBegin('type', TType.I64, 1)
9652 
      oprot.writeI64(self.type)
94 ashish 9653 
      oprot.writeFieldEnd()
4444 rajveer 9654 
    if self.warehouseId is not None:
9655 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9656 
      oprot.writeI64(self.warehouseId)
9657 
      oprot.writeFieldEnd()
4394 rajveer 9658 
    if self.status is not None:
4444 rajveer 9659 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9660 
      oprot.writeI64(self.status)
3064 chandransh 9661 
      oprot.writeFieldEnd()
4394 rajveer 9662 
    if self.timestamp is not None:
4444 rajveer 9663 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9664 
      oprot.writeI64(self.timestamp)
9665 
      oprot.writeFieldEnd()
94 ashish 9666 
    oprot.writeFieldStop()
9667 
    oprot.writeStructEnd()
9668 
 
3431 rajveer 9669 
  def validate(self):
9670 
    return
9671 
 
9672 
 
94 ashish 9673 
  def __repr__(self):
9674 
    L = ['%s=%r' % (key, value)
9675 
      for key, value in self.__dict__.iteritems()]
9676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9677 
 
9678 
  def __eq__(self, other):
9679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9680 
 
9681 
  def __ne__(self, other):
9682 
    return not (self == other)
9683 
 
3064 chandransh 9684 
class getAlerts_result:
94 ashish 9685 
  """
9686 
  Attributes:
9687 
   - success
9688 
  """
9689 
 
9690 
  thrift_spec = (
3064 chandransh 9691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9692 
  )
9693 
 
3064 chandransh 9694 
  def __init__(self, success=None,):
94 ashish 9695 
    self.success = success
9696 
 
9697 
  def read(self, iprot):
9698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9700 
      return
9701 
    iprot.readStructBegin()
9702 
    while True:
9703 
      (fname, ftype, fid) = iprot.readFieldBegin()
9704 
      if ftype == TType.STOP:
9705 
        break
9706 
      if fid == 0:
3064 chandransh 9707 
        if ftype == TType.LIST:
9708 
          self.success = []
4837 varun.gupt 9709 
          (_etype150, _size147) = iprot.readListBegin()
9710 
          for _i151 in xrange(_size147):
9711 
            _elem152 = Alert()
9712 
            _elem152.read(iprot)
9713 
            self.success.append(_elem152)
3064 chandransh 9714 
          iprot.readListEnd()
94 ashish 9715 
        else:
9716 
          iprot.skip(ftype)
9717 
      else:
9718 
        iprot.skip(ftype)
9719 
      iprot.readFieldEnd()
9720 
    iprot.readStructEnd()
9721 
 
9722 
  def write(self, oprot):
9723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9725 
      return
3064 chandransh 9726 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9727 
    if self.success is not None:
3064 chandransh 9728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9730 
      for iter153 in self.success:
9731 
        iter153.write(oprot)
3064 chandransh 9732 
      oprot.writeListEnd()
94 ashish 9733 
      oprot.writeFieldEnd()
9734 
    oprot.writeFieldStop()
9735 
    oprot.writeStructEnd()
9736 
 
3431 rajveer 9737 
  def validate(self):
9738 
    return
9739 
 
9740 
 
94 ashish 9741 
  def __repr__(self):
9742 
    L = ['%s=%r' % (key, value)
9743 
      for key, value in self.__dict__.iteritems()]
9744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9745 
 
9746 
  def __eq__(self, other):
9747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9748 
 
9749 
  def __ne__(self, other):
9750 
    return not (self == other)
9751 
 
4394 rajveer 9752 
class addAlert_args:
94 ashish 9753 
  """
9754 
  Attributes:
3064 chandransh 9755 
   - type
4444 rajveer 9756 
   - warehouseId
4394 rajveer 9757 
   - description
94 ashish 9758 
  """
9759 
 
9760 
  thrift_spec = (
9761 
    None, # 0
4394 rajveer 9762 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9763 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9764 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9765 
  )
9766 
 
4444 rajveer 9767 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9768 
    self.type = type
4444 rajveer 9769 
    self.warehouseId = warehouseId
4394 rajveer 9770 
    self.description = description
94 ashish 9771 
 
9772 
  def read(self, iprot):
9773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9775 
      return
9776 
    iprot.readStructBegin()
9777 
    while True:
9778 
      (fname, ftype, fid) = iprot.readFieldBegin()
9779 
      if ftype == TType.STOP:
9780 
        break
9781 
      if fid == 1:
9782 
        if ftype == TType.I64:
4394 rajveer 9783 
          self.type = iprot.readI64();
94 ashish 9784 
        else:
9785 
          iprot.skip(ftype)
3064 chandransh 9786 
      elif fid == 2:
4444 rajveer 9787 
        if ftype == TType.I64:
9788 
          self.warehouseId = iprot.readI64();
9789 
        else:
9790 
          iprot.skip(ftype)
9791 
      elif fid == 3:
3064 chandransh 9792 
        if ftype == TType.STRING:
4394 rajveer 9793 
          self.description = iprot.readString();
3064 chandransh 9794 
        else:
9795 
          iprot.skip(ftype)
94 ashish 9796 
      else:
9797 
        iprot.skip(ftype)
9798 
      iprot.readFieldEnd()
9799 
    iprot.readStructEnd()
9800 
 
9801 
  def write(self, oprot):
9802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9804 
      return
4394 rajveer 9805 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9806 
    if self.type is not None:
4394 rajveer 9807 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9808 
      oprot.writeI64(self.type)
9809 
      oprot.writeFieldEnd()
4444 rajveer 9810 
    if self.warehouseId is not None:
9811 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9812 
      oprot.writeI64(self.warehouseId)
9813 
      oprot.writeFieldEnd()
4394 rajveer 9814 
    if self.description is not None:
4444 rajveer 9815 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9816 
      oprot.writeString(self.description)
3064 chandransh 9817 
      oprot.writeFieldEnd()
94 ashish 9818 
    oprot.writeFieldStop()
9819 
    oprot.writeStructEnd()
9820 
 
3431 rajveer 9821 
  def validate(self):
9822 
    return
9823 
 
9824 
 
94 ashish 9825 
  def __repr__(self):
9826 
    L = ['%s=%r' % (key, value)
9827 
      for key, value in self.__dict__.iteritems()]
9828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9829 
 
9830 
  def __eq__(self, other):
9831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9832 
 
9833 
  def __ne__(self, other):
9834 
    return not (self == other)
9835 
 
4394 rajveer 9836 
class addAlert_result:
3064 chandransh 9837 
 
9838 
  thrift_spec = (
9839 
  )
9840 
 
9841 
  def read(self, iprot):
9842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9844 
      return
9845 
    iprot.readStructBegin()
9846 
    while True:
9847 
      (fname, ftype, fid) = iprot.readFieldBegin()
9848 
      if ftype == TType.STOP:
9849 
        break
9850 
      else:
9851 
        iprot.skip(ftype)
9852 
      iprot.readFieldEnd()
9853 
    iprot.readStructEnd()
9854 
 
9855 
  def write(self, oprot):
9856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9858 
      return
4394 rajveer 9859 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
3431 rajveer 9863 
  def validate(self):
9864 
    return
9865 
 
9866 
 
3064 chandransh 9867 
  def __repr__(self):
9868 
    L = ['%s=%r' % (key, value)
9869 
      for key, value in self.__dict__.iteritems()]
9870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9871 
 
9872 
  def __eq__(self, other):
9873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9874 
 
9875 
  def __ne__(self, other):
9876 
    return not (self == other)
9877 
 
4444 rajveer 9878 
class markAlertsAsSeen_args:
9879 
  """
9880 
  Attributes:
9881 
   - warehouseId
9882 
  """
9883 
 
9884 
  thrift_spec = (
9885 
    None, # 0
9886 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9887 
  )
9888 
 
9889 
  def __init__(self, warehouseId=None,):
9890 
    self.warehouseId = warehouseId
9891 
 
9892 
  def read(self, iprot):
9893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9895 
      return
9896 
    iprot.readStructBegin()
9897 
    while True:
9898 
      (fname, ftype, fid) = iprot.readFieldBegin()
9899 
      if ftype == TType.STOP:
9900 
        break
9901 
      if fid == 1:
9902 
        if ftype == TType.I64:
9903 
          self.warehouseId = iprot.readI64();
9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      else:
9907 
        iprot.skip(ftype)
9908 
      iprot.readFieldEnd()
9909 
    iprot.readStructEnd()
9910 
 
9911 
  def write(self, oprot):
9912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9914 
      return
9915 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9916 
    if self.warehouseId is not None:
9917 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9918 
      oprot.writeI64(self.warehouseId)
9919 
      oprot.writeFieldEnd()
9920 
    oprot.writeFieldStop()
9921 
    oprot.writeStructEnd()
9922 
 
9923 
  def validate(self):
9924 
    return
9925 
 
9926 
 
9927 
  def __repr__(self):
9928 
    L = ['%s=%r' % (key, value)
9929 
      for key, value in self.__dict__.iteritems()]
9930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9931 
 
9932 
  def __eq__(self, other):
9933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9934 
 
9935 
  def __ne__(self, other):
9936 
    return not (self == other)
9937 
 
9938 
class markAlertsAsSeen_result:
9939 
 
9940 
  thrift_spec = (
9941 
  )
9942 
 
9943 
  def read(self, iprot):
9944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9946 
      return
9947 
    iprot.readStructBegin()
9948 
    while True:
9949 
      (fname, ftype, fid) = iprot.readFieldBegin()
9950 
      if ftype == TType.STOP:
9951 
        break
9952 
      else:
9953 
        iprot.skip(ftype)
9954 
      iprot.readFieldEnd()
9955 
    iprot.readStructEnd()
9956 
 
9957 
  def write(self, oprot):
9958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9960 
      return
9961 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9962 
    oprot.writeFieldStop()
9963 
    oprot.writeStructEnd()
9964 
 
9965 
  def validate(self):
9966 
    return
9967 
 
9968 
 
9969 
  def __repr__(self):
9970 
    L = ['%s=%r' % (key, value)
9971 
      for key, value in self.__dict__.iteritems()]
9972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9973 
 
9974 
  def __eq__(self, other):
9975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9976 
 
9977 
  def __ne__(self, other):
9978 
    return not (self == other)
9979 
 
3064 chandransh 9980 
class getValidOrderCount_args:
9981 
 
9982 
  thrift_spec = (
9983 
  )
9984 
 
9985 
  def read(self, iprot):
9986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9988 
      return
9989 
    iprot.readStructBegin()
9990 
    while True:
9991 
      (fname, ftype, fid) = iprot.readFieldBegin()
9992 
      if ftype == TType.STOP:
9993 
        break
9994 
      else:
9995 
        iprot.skip(ftype)
9996 
      iprot.readFieldEnd()
9997 
    iprot.readStructEnd()
9998 
 
9999 
  def write(self, oprot):
10000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10002 
      return
10003 
    oprot.writeStructBegin('getValidOrderCount_args')
10004 
    oprot.writeFieldStop()
10005 
    oprot.writeStructEnd()
10006 
 
3431 rajveer 10007 
  def validate(self):
10008 
    return
10009 
 
10010 
 
3064 chandransh 10011 
  def __repr__(self):
10012 
    L = ['%s=%r' % (key, value)
10013 
      for key, value in self.__dict__.iteritems()]
10014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10015 
 
10016 
  def __eq__(self, other):
10017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10018 
 
10019 
  def __ne__(self, other):
10020 
    return not (self == other)
10021 
 
10022 
class getValidOrderCount_result:
94 ashish 10023 
  """
10024 
  Attributes:
10025 
   - success
10026 
  """
10027 
 
10028 
  thrift_spec = (
3064 chandransh 10029 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10030 
  )
10031 
 
3064 chandransh 10032 
  def __init__(self, success=None,):
94 ashish 10033 
    self.success = success
10034 
 
10035 
  def read(self, iprot):
10036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10038 
      return
10039 
    iprot.readStructBegin()
10040 
    while True:
10041 
      (fname, ftype, fid) = iprot.readFieldBegin()
10042 
      if ftype == TType.STOP:
10043 
        break
10044 
      if fid == 0:
3064 chandransh 10045 
        if ftype == TType.I64:
10046 
          self.success = iprot.readI64();
94 ashish 10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      else:
10050 
        iprot.skip(ftype)
10051 
      iprot.readFieldEnd()
10052 
    iprot.readStructEnd()
10053 
 
10054 
  def write(self, oprot):
10055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10057 
      return
3064 chandransh 10058 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10059 
    if self.success is not None:
3064 chandransh 10060 
      oprot.writeFieldBegin('success', TType.I64, 0)
10061 
      oprot.writeI64(self.success)
94 ashish 10062 
      oprot.writeFieldEnd()
10063 
    oprot.writeFieldStop()
10064 
    oprot.writeStructEnd()
10065 
 
3431 rajveer 10066 
  def validate(self):
10067 
    return
10068 
 
10069 
 
94 ashish 10070 
  def __repr__(self):
10071 
    L = ['%s=%r' % (key, value)
10072 
      for key, value in self.__dict__.iteritems()]
10073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10074 
 
10075 
  def __eq__(self, other):
10076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10077 
 
10078 
  def __ne__(self, other):
10079 
    return not (self == other)
10080 
 
3064 chandransh 10081 
class getNoOfCustomersWithSuccessfulTransaction_args:
10082 
 
10083 
  thrift_spec = (
10084 
  )
10085 
 
10086 
  def read(self, iprot):
10087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10089 
      return
10090 
    iprot.readStructBegin()
10091 
    while True:
10092 
      (fname, ftype, fid) = iprot.readFieldBegin()
10093 
      if ftype == TType.STOP:
10094 
        break
10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
10104 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10105 
    oprot.writeFieldStop()
10106 
    oprot.writeStructEnd()
10107 
 
3431 rajveer 10108 
  def validate(self):
10109 
    return
10110 
 
10111 
 
3064 chandransh 10112 
  def __repr__(self):
10113 
    L = ['%s=%r' % (key, value)
10114 
      for key, value in self.__dict__.iteritems()]
10115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10116 
 
10117 
  def __eq__(self, other):
10118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10119 
 
10120 
  def __ne__(self, other):
10121 
    return not (self == other)
10122 
 
10123 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10124 
  """
10125 
  Attributes:
3064 chandransh 10126 
   - success
94 ashish 10127 
  """
10128 
 
10129 
  thrift_spec = (
3064 chandransh 10130 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10131 
  )
10132 
 
3064 chandransh 10133 
  def __init__(self, success=None,):
10134 
    self.success = success
94 ashish 10135 
 
10136 
  def read(self, iprot):
10137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10139 
      return
10140 
    iprot.readStructBegin()
10141 
    while True:
10142 
      (fname, ftype, fid) = iprot.readFieldBegin()
10143 
      if ftype == TType.STOP:
10144 
        break
3064 chandransh 10145 
      if fid == 0:
94 ashish 10146 
        if ftype == TType.I64:
3064 chandransh 10147 
          self.success = iprot.readI64();
94 ashish 10148 
        else:
10149 
          iprot.skip(ftype)
10150 
      else:
10151 
        iprot.skip(ftype)
10152 
      iprot.readFieldEnd()
10153 
    iprot.readStructEnd()
10154 
 
10155 
  def write(self, oprot):
10156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10158 
      return
3064 chandransh 10159 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10160 
    if self.success is not None:
3064 chandransh 10161 
      oprot.writeFieldBegin('success', TType.I64, 0)
10162 
      oprot.writeI64(self.success)
94 ashish 10163 
      oprot.writeFieldEnd()
10164 
    oprot.writeFieldStop()
10165 
    oprot.writeStructEnd()
10166 
 
3431 rajveer 10167 
  def validate(self):
10168 
    return
10169 
 
10170 
 
94 ashish 10171 
  def __repr__(self):
10172 
    L = ['%s=%r' % (key, value)
10173 
      for key, value in self.__dict__.iteritems()]
10174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10175 
 
10176 
  def __eq__(self, other):
10177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10178 
 
10179 
  def __ne__(self, other):
10180 
    return not (self == other)
10181 
 
3064 chandransh 10182 
class getValidOrdersAmountRange_args:
10183 
 
10184 
  thrift_spec = (
10185 
  )
10186 
 
10187 
  def read(self, iprot):
10188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10190 
      return
10191 
    iprot.readStructBegin()
10192 
    while True:
10193 
      (fname, ftype, fid) = iprot.readFieldBegin()
10194 
      if ftype == TType.STOP:
10195 
        break
10196 
      else:
10197 
        iprot.skip(ftype)
10198 
      iprot.readFieldEnd()
10199 
    iprot.readStructEnd()
10200 
 
10201 
  def write(self, oprot):
10202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10204 
      return
10205 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
3431 rajveer 10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
3064 chandransh 10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
10224 
class getValidOrdersAmountRange_result:
94 ashish 10225 
  """
10226 
  Attributes:
10227 
   - success
10228 
  """
10229 
 
10230 
  thrift_spec = (
3064 chandransh 10231 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10232 
  )
10233 
 
3064 chandransh 10234 
  def __init__(self, success=None,):
94 ashish 10235 
    self.success = success
10236 
 
10237 
  def read(self, iprot):
10238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10240 
      return
10241 
    iprot.readStructBegin()
10242 
    while True:
10243 
      (fname, ftype, fid) = iprot.readFieldBegin()
10244 
      if ftype == TType.STOP:
10245 
        break
10246 
      if fid == 0:
483 rajveer 10247 
        if ftype == TType.LIST:
10248 
          self.success = []
4837 varun.gupt 10249 
          (_etype157, _size154) = iprot.readListBegin()
10250 
          for _i158 in xrange(_size154):
10251 
            _elem159 = iprot.readDouble();
10252 
            self.success.append(_elem159)
483 rajveer 10253 
          iprot.readListEnd()
94 ashish 10254 
        else:
10255 
          iprot.skip(ftype)
10256 
      else:
10257 
        iprot.skip(ftype)
10258 
      iprot.readFieldEnd()
10259 
    iprot.readStructEnd()
10260 
 
10261 
  def write(self, oprot):
10262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10264 
      return
3064 chandransh 10265 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10266 
    if self.success is not None:
483 rajveer 10267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10268 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4837 varun.gupt 10269 
      for iter160 in self.success:
10270 
        oprot.writeDouble(iter160)
483 rajveer 10271 
      oprot.writeListEnd()
94 ashish 10272 
      oprot.writeFieldEnd()
10273 
    oprot.writeFieldStop()
10274 
    oprot.writeStructEnd()
10275 
 
3431 rajveer 10276 
  def validate(self):
10277 
    return
10278 
 
10279 
 
94 ashish 10280 
  def __repr__(self):
10281 
    L = ['%s=%r' % (key, value)
10282 
      for key, value in self.__dict__.iteritems()]
10283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10284 
 
10285 
  def __eq__(self, other):
10286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10287 
 
10288 
  def __ne__(self, other):
10289 
    return not (self == other)
10290 
 
3064 chandransh 10291 
class getValidOrders_args:
1528 ankur.sing 10292 
  """
10293 
  Attributes:
3064 chandransh 10294 
   - limit
1528 ankur.sing 10295 
  """
10296 
 
10297 
  thrift_spec = (
10298 
    None, # 0
3064 chandransh 10299 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10300 
  )
10301 
 
3064 chandransh 10302 
  def __init__(self, limit=None,):
10303 
    self.limit = limit
1528 ankur.sing 10304 
 
10305 
  def read(self, iprot):
10306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10308 
      return
10309 
    iprot.readStructBegin()
10310 
    while True:
10311 
      (fname, ftype, fid) = iprot.readFieldBegin()
10312 
      if ftype == TType.STOP:
10313 
        break
10314 
      if fid == 1:
10315 
        if ftype == TType.I64:
3064 chandransh 10316 
          self.limit = iprot.readI64();
1528 ankur.sing 10317 
        else:
10318 
          iprot.skip(ftype)
10319 
      else:
10320 
        iprot.skip(ftype)
10321 
      iprot.readFieldEnd()
10322 
    iprot.readStructEnd()
10323 
 
10324 
  def write(self, oprot):
10325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10327 
      return
3064 chandransh 10328 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10329 
    if self.limit is not None:
3064 chandransh 10330 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10331 
      oprot.writeI64(self.limit)
1528 ankur.sing 10332 
      oprot.writeFieldEnd()
10333 
    oprot.writeFieldStop()
10334 
    oprot.writeStructEnd()
10335 
 
3431 rajveer 10336 
  def validate(self):
10337 
    return
10338 
 
10339 
 
1528 ankur.sing 10340 
  def __repr__(self):
10341 
    L = ['%s=%r' % (key, value)
10342 
      for key, value in self.__dict__.iteritems()]
10343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10344 
 
10345 
  def __eq__(self, other):
10346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10347 
 
10348 
  def __ne__(self, other):
10349 
    return not (self == other)
10350 
 
3064 chandransh 10351 
class getValidOrders_result:
1528 ankur.sing 10352 
  """
10353 
  Attributes:
10354 
   - success
10355 
  """
10356 
 
10357 
  thrift_spec = (
3064 chandransh 10358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10359 
  )
10360 
 
3064 chandransh 10361 
  def __init__(self, success=None,):
1528 ankur.sing 10362 
    self.success = success
10363 
 
10364 
  def read(self, iprot):
10365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10367 
      return
10368 
    iprot.readStructBegin()
10369 
    while True:
10370 
      (fname, ftype, fid) = iprot.readFieldBegin()
10371 
      if ftype == TType.STOP:
10372 
        break
10373 
      if fid == 0:
3064 chandransh 10374 
        if ftype == TType.LIST:
10375 
          self.success = []
4837 varun.gupt 10376 
          (_etype164, _size161) = iprot.readListBegin()
10377 
          for _i165 in xrange(_size161):
10378 
            _elem166 = Order()
10379 
            _elem166.read(iprot)
10380 
            self.success.append(_elem166)
3064 chandransh 10381 
          iprot.readListEnd()
1528 ankur.sing 10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      else:
10385 
        iprot.skip(ftype)
10386 
      iprot.readFieldEnd()
10387 
    iprot.readStructEnd()
10388 
 
10389 
  def write(self, oprot):
10390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10392 
      return
3064 chandransh 10393 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10394 
    if self.success is not None:
3064 chandransh 10395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 10397 
      for iter167 in self.success:
10398 
        iter167.write(oprot)
3064 chandransh 10399 
      oprot.writeListEnd()
1528 ankur.sing 10400 
      oprot.writeFieldEnd()
10401 
    oprot.writeFieldStop()
10402 
    oprot.writeStructEnd()
10403 
 
3431 rajveer 10404 
  def validate(self):
10405 
    return
10406 
 
10407 
 
1528 ankur.sing 10408 
  def __repr__(self):
10409 
    L = ['%s=%r' % (key, value)
10410 
      for key, value in self.__dict__.iteritems()]
10411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10412 
 
10413 
  def __eq__(self, other):
10414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10415 
 
10416 
  def __ne__(self, other):
10417 
    return not (self == other)
10418 
 
1220 chandransh 10419 
class batchOrders_args:
10420 
  """
10421 
  Attributes:
10422 
   - warehouseId
10423 
  """
10424 
 
10425 
  thrift_spec = (
10426 
    None, # 0
10427 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10428 
  )
10429 
 
10430 
  def __init__(self, warehouseId=None,):
10431 
    self.warehouseId = warehouseId
10432 
 
10433 
  def read(self, iprot):
10434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10436 
      return
10437 
    iprot.readStructBegin()
10438 
    while True:
10439 
      (fname, ftype, fid) = iprot.readFieldBegin()
10440 
      if ftype == TType.STOP:
10441 
        break
10442 
      if fid == 1:
10443 
        if ftype == TType.I64:
10444 
          self.warehouseId = iprot.readI64();
10445 
        else:
10446 
          iprot.skip(ftype)
10447 
      else:
10448 
        iprot.skip(ftype)
10449 
      iprot.readFieldEnd()
10450 
    iprot.readStructEnd()
10451 
 
10452 
  def write(self, oprot):
10453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10455 
      return
10456 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10457 
    if self.warehouseId is not None:
1220 chandransh 10458 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10459 
      oprot.writeI64(self.warehouseId)
10460 
      oprot.writeFieldEnd()
10461 
    oprot.writeFieldStop()
10462 
    oprot.writeStructEnd()
10463 
 
3431 rajveer 10464 
  def validate(self):
10465 
    return
10466 
 
10467 
 
1220 chandransh 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 
 
10479 
class batchOrders_result:
10480 
  """
10481 
  Attributes:
10482 
   - success
10483 
   - ex
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10489 
  )
10490 
 
10491 
  def __init__(self, success=None, ex=None,):
10492 
    self.success = success
10493 
    self.ex = ex
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 0:
10505 
        if ftype == TType.LIST:
10506 
          self.success = []
4837 varun.gupt 10507 
          (_etype171, _size168) = iprot.readListBegin()
10508 
          for _i172 in xrange(_size168):
10509 
            _elem173 = Order()
10510 
            _elem173.read(iprot)
10511 
            self.success.append(_elem173)
1220 chandransh 10512 
          iprot.readListEnd()
10513 
        else:
10514 
          iprot.skip(ftype)
10515 
      elif fid == 1:
10516 
        if ftype == TType.STRUCT:
10517 
          self.ex = TransactionServiceException()
10518 
          self.ex.read(iprot)
10519 
        else:
10520 
          iprot.skip(ftype)
10521 
      else:
10522 
        iprot.skip(ftype)
10523 
      iprot.readFieldEnd()
10524 
    iprot.readStructEnd()
10525 
 
10526 
  def write(self, oprot):
10527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10529 
      return
10530 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10531 
    if self.success is not None:
1220 chandransh 10532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 10534 
      for iter174 in self.success:
10535 
        iter174.write(oprot)
1220 chandransh 10536 
      oprot.writeListEnd()
10537 
      oprot.writeFieldEnd()
3431 rajveer 10538 
    if self.ex is not None:
1220 chandransh 10539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10540 
      self.ex.write(oprot)
10541 
      oprot.writeFieldEnd()
10542 
    oprot.writeFieldStop()
10543 
    oprot.writeStructEnd()
10544 
 
3431 rajveer 10545 
  def validate(self):
10546 
    return
10547 
 
10548 
 
1220 chandransh 10549 
  def __repr__(self):
10550 
    L = ['%s=%r' % (key, value)
10551 
      for key, value in self.__dict__.iteritems()]
10552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10553 
 
10554 
  def __eq__(self, other):
10555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10556 
 
10557 
  def __ne__(self, other):
10558 
    return not (self == other)
10559 
 
1208 chandransh 10560 
class markOrderAsOutOfStock_args:
10561 
  """
10562 
  Attributes:
10563 
   - orderId
10564 
  """
10565 
 
10566 
  thrift_spec = (
10567 
    None, # 0
10568 
    (1, TType.I64, 'orderId', None, None, ), # 1
10569 
  )
10570 
 
10571 
  def __init__(self, orderId=None,):
10572 
    self.orderId = orderId
10573 
 
10574 
  def read(self, iprot):
10575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10577 
      return
10578 
    iprot.readStructBegin()
10579 
    while True:
10580 
      (fname, ftype, fid) = iprot.readFieldBegin()
10581 
      if ftype == TType.STOP:
10582 
        break
10583 
      if fid == 1:
10584 
        if ftype == TType.I64:
10585 
          self.orderId = iprot.readI64();
10586 
        else:
10587 
          iprot.skip(ftype)
10588 
      else:
10589 
        iprot.skip(ftype)
10590 
      iprot.readFieldEnd()
10591 
    iprot.readStructEnd()
10592 
 
10593 
  def write(self, oprot):
10594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10596 
      return
10597 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10598 
    if self.orderId is not None:
1208 chandransh 10599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10600 
      oprot.writeI64(self.orderId)
10601 
      oprot.writeFieldEnd()
10602 
    oprot.writeFieldStop()
10603 
    oprot.writeStructEnd()
10604 
 
3431 rajveer 10605 
  def validate(self):
10606 
    return
10607 
 
10608 
 
1208 chandransh 10609 
  def __repr__(self):
10610 
    L = ['%s=%r' % (key, value)
10611 
      for key, value in self.__dict__.iteritems()]
10612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10613 
 
10614 
  def __eq__(self, other):
10615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10616 
 
10617 
  def __ne__(self, other):
10618 
    return not (self == other)
10619 
 
10620 
class markOrderAsOutOfStock_result:
10621 
  """
10622 
  Attributes:
10623 
   - success
10624 
   - ex
10625 
  """
10626 
 
10627 
  thrift_spec = (
10628 
    (0, TType.BOOL, 'success', None, None, ), # 0
10629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10630 
  )
10631 
 
10632 
  def __init__(self, success=None, ex=None,):
10633 
    self.success = success
10634 
    self.ex = ex
10635 
 
10636 
  def read(self, iprot):
10637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10639 
      return
10640 
    iprot.readStructBegin()
10641 
    while True:
10642 
      (fname, ftype, fid) = iprot.readFieldBegin()
10643 
      if ftype == TType.STOP:
10644 
        break
10645 
      if fid == 0:
10646 
        if ftype == TType.BOOL:
10647 
          self.success = iprot.readBool();
10648 
        else:
10649 
          iprot.skip(ftype)
10650 
      elif fid == 1:
10651 
        if ftype == TType.STRUCT:
10652 
          self.ex = TransactionServiceException()
10653 
          self.ex.read(iprot)
10654 
        else:
10655 
          iprot.skip(ftype)
10656 
      else:
10657 
        iprot.skip(ftype)
10658 
      iprot.readFieldEnd()
10659 
    iprot.readStructEnd()
10660 
 
10661 
  def write(self, oprot):
10662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10664 
      return
10665 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10666 
    if self.success is not None:
1208 chandransh 10667 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10668 
      oprot.writeBool(self.success)
10669 
      oprot.writeFieldEnd()
3431 rajveer 10670 
    if self.ex is not None:
1208 chandransh 10671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10672 
      self.ex.write(oprot)
10673 
      oprot.writeFieldEnd()
10674 
    oprot.writeFieldStop()
10675 
    oprot.writeStructEnd()
10676 
 
3431 rajveer 10677 
  def validate(self):
10678 
    return
10679 
 
10680 
 
1208 chandransh 10681 
  def __repr__(self):
10682 
    L = ['%s=%r' % (key, value)
10683 
      for key, value in self.__dict__.iteritems()]
10684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10685 
 
10686 
  def __eq__(self, other):
10687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10688 
 
10689 
  def __ne__(self, other):
10690 
    return not (self == other)
10691 
 
3064 chandransh 10692 
class verifyOrder_args:
759 chandransh 10693 
  """
10694 
  Attributes:
3064 chandransh 10695 
   - orderId
759 chandransh 10696 
  """
10697 
 
10698 
  thrift_spec = (
10699 
    None, # 0
3064 chandransh 10700 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10701 
  )
10702 
 
3064 chandransh 10703 
  def __init__(self, orderId=None,):
10704 
    self.orderId = orderId
759 chandransh 10705 
 
10706 
  def read(self, iprot):
10707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10709 
      return
10710 
    iprot.readStructBegin()
10711 
    while True:
10712 
      (fname, ftype, fid) = iprot.readFieldBegin()
10713 
      if ftype == TType.STOP:
10714 
        break
10715 
      if fid == 1:
10716 
        if ftype == TType.I64:
3064 chandransh 10717 
          self.orderId = iprot.readI64();
759 chandransh 10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      else:
10721 
        iprot.skip(ftype)
10722 
      iprot.readFieldEnd()
10723 
    iprot.readStructEnd()
10724 
 
10725 
  def write(self, oprot):
10726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10728 
      return
3064 chandransh 10729 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10730 
    if self.orderId is not None:
3064 chandransh 10731 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10732 
      oprot.writeI64(self.orderId)
759 chandransh 10733 
      oprot.writeFieldEnd()
10734 
    oprot.writeFieldStop()
10735 
    oprot.writeStructEnd()
10736 
 
3431 rajveer 10737 
  def validate(self):
10738 
    return
10739 
 
10740 
 
759 chandransh 10741 
  def __repr__(self):
10742 
    L = ['%s=%r' % (key, value)
10743 
      for key, value in self.__dict__.iteritems()]
10744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10745 
 
10746 
  def __eq__(self, other):
10747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10748 
 
10749 
  def __ne__(self, other):
10750 
    return not (self == other)
10751 
 
3064 chandransh 10752 
class verifyOrder_result:
759 chandransh 10753 
  """
10754 
  Attributes:
10755 
   - success
10756 
   - ex
10757 
  """
10758 
 
10759 
  thrift_spec = (
10760 
    (0, TType.BOOL, 'success', None, None, ), # 0
10761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10762 
  )
10763 
 
10764 
  def __init__(self, success=None, ex=None,):
10765 
    self.success = success
10766 
    self.ex = ex
10767 
 
10768 
  def read(self, iprot):
10769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10771 
      return
10772 
    iprot.readStructBegin()
10773 
    while True:
10774 
      (fname, ftype, fid) = iprot.readFieldBegin()
10775 
      if ftype == TType.STOP:
10776 
        break
10777 
      if fid == 0:
10778 
        if ftype == TType.BOOL:
10779 
          self.success = iprot.readBool();
10780 
        else:
10781 
          iprot.skip(ftype)
10782 
      elif fid == 1:
10783 
        if ftype == TType.STRUCT:
10784 
          self.ex = TransactionServiceException()
10785 
          self.ex.read(iprot)
10786 
        else:
10787 
          iprot.skip(ftype)
10788 
      else:
10789 
        iprot.skip(ftype)
10790 
      iprot.readFieldEnd()
10791 
    iprot.readStructEnd()
10792 
 
10793 
  def write(self, oprot):
10794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10796 
      return
3064 chandransh 10797 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10798 
    if self.success is not None:
759 chandransh 10799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10800 
      oprot.writeBool(self.success)
10801 
      oprot.writeFieldEnd()
3431 rajveer 10802 
    if self.ex is not None:
759 chandransh 10803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10804 
      self.ex.write(oprot)
10805 
      oprot.writeFieldEnd()
10806 
    oprot.writeFieldStop()
10807 
    oprot.writeStructEnd()
10808 
 
3431 rajveer 10809 
  def validate(self):
10810 
    return
10811 
 
10812 
 
759 chandransh 10813 
  def __repr__(self):
10814 
    L = ['%s=%r' % (key, value)
10815 
      for key, value in self.__dict__.iteritems()]
10816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10817 
 
10818 
  def __eq__(self, other):
10819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10820 
 
10821 
  def __ne__(self, other):
10822 
    return not (self == other)
10823 
 
3064 chandransh 10824 
class acceptOrder_args:
1113 chandransh 10825 
  """
10826 
  Attributes:
3064 chandransh 10827 
   - orderId
1113 chandransh 10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    None, # 0
3064 chandransh 10832 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10833 
  )
10834 
 
3064 chandransh 10835 
  def __init__(self, orderId=None,):
10836 
    self.orderId = orderId
1113 chandransh 10837 
 
10838 
  def read(self, iprot):
10839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10841 
      return
10842 
    iprot.readStructBegin()
10843 
    while True:
10844 
      (fname, ftype, fid) = iprot.readFieldBegin()
10845 
      if ftype == TType.STOP:
10846 
        break
10847 
      if fid == 1:
10848 
        if ftype == TType.I64:
3064 chandransh 10849 
          self.orderId = iprot.readI64();
1113 chandransh 10850 
        else:
10851 
          iprot.skip(ftype)
10852 
      else:
10853 
        iprot.skip(ftype)
10854 
      iprot.readFieldEnd()
10855 
    iprot.readStructEnd()
10856 
 
10857 
  def write(self, oprot):
10858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10860 
      return
3064 chandransh 10861 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10862 
    if self.orderId is not None:
3064 chandransh 10863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10864 
      oprot.writeI64(self.orderId)
1113 chandransh 10865 
      oprot.writeFieldEnd()
10866 
    oprot.writeFieldStop()
10867 
    oprot.writeStructEnd()
10868 
 
3431 rajveer 10869 
  def validate(self):
10870 
    return
10871 
 
10872 
 
1113 chandransh 10873 
  def __repr__(self):
10874 
    L = ['%s=%r' % (key, value)
10875 
      for key, value in self.__dict__.iteritems()]
10876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10877 
 
10878 
  def __eq__(self, other):
10879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10880 
 
10881 
  def __ne__(self, other):
10882 
    return not (self == other)
10883 
 
3064 chandransh 10884 
class acceptOrder_result:
1113 chandransh 10885 
  """
10886 
  Attributes:
10887 
   - success
10888 
   - ex
10889 
  """
10890 
 
10891 
  thrift_spec = (
3064 chandransh 10892 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10894 
  )
10895 
 
10896 
  def __init__(self, success=None, ex=None,):
10897 
    self.success = success
10898 
    self.ex = ex
10899 
 
10900 
  def read(self, iprot):
10901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10903 
      return
10904 
    iprot.readStructBegin()
10905 
    while True:
10906 
      (fname, ftype, fid) = iprot.readFieldBegin()
10907 
      if ftype == TType.STOP:
10908 
        break
10909 
      if fid == 0:
3064 chandransh 10910 
        if ftype == TType.BOOL:
10911 
          self.success = iprot.readBool();
1113 chandransh 10912 
        else:
10913 
          iprot.skip(ftype)
10914 
      elif fid == 1:
10915 
        if ftype == TType.STRUCT:
10916 
          self.ex = TransactionServiceException()
10917 
          self.ex.read(iprot)
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
3064 chandransh 10929 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10930 
    if self.success is not None:
3064 chandransh 10931 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10932 
      oprot.writeBool(self.success)
1113 chandransh 10933 
      oprot.writeFieldEnd()
3431 rajveer 10934 
    if self.ex is not None:
1113 chandransh 10935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10936 
      self.ex.write(oprot)
10937 
      oprot.writeFieldEnd()
10938 
    oprot.writeFieldStop()
10939 
    oprot.writeStructEnd()
10940 
 
3431 rajveer 10941 
  def validate(self):
10942 
    return
10943 
 
10944 
 
1113 chandransh 10945 
  def __repr__(self):
10946 
    L = ['%s=%r' % (key, value)
10947 
      for key, value in self.__dict__.iteritems()]
10948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10949 
 
10950 
  def __eq__(self, other):
10951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10952 
 
10953 
  def __ne__(self, other):
10954 
    return not (self == other)
10955 
 
3064 chandransh 10956 
class addBillingDetails_args:
1135 chandransh 10957 
  """
10958 
  Attributes:
3064 chandransh 10959 
   - orderId
10960 
   - invoice_number
4658 mandeep.dh 10961 
   - serialNumber
4283 anupam.sin 10962 
   - itemNumber
3064 chandransh 10963 
   - billed_by
4264 rajveer 10964 
   - jacketNumber
4283 anupam.sin 10965 
   - billingType
10966 
   - vendorId
4763 rajveer 10967 
   - authorize
1135 chandransh 10968 
  """
10969 
 
10970 
  thrift_spec = (
10971 
    None, # 0
3064 chandransh 10972 
    (1, TType.I64, 'orderId', None, None, ), # 1
10973 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10974 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10975 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10976 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10977 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10978 
    (7, TType.I64, 'billingType', None, None, ), # 7
10979 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10980 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10981 
  )
10982 
 
4763 rajveer 10983 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None, authorize=None,):
3064 chandransh 10984 
    self.orderId = orderId
10985 
    self.invoice_number = invoice_number
4658 mandeep.dh 10986 
    self.serialNumber = serialNumber
4283 anupam.sin 10987 
    self.itemNumber = itemNumber
3064 chandransh 10988 
    self.billed_by = billed_by
4264 rajveer 10989 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10990 
    self.billingType = billingType
10991 
    self.vendorId = vendorId
4763 rajveer 10992 
    self.authorize = authorize
1135 chandransh 10993 
 
10994 
  def read(self, iprot):
10995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10997 
      return
10998 
    iprot.readStructBegin()
10999 
    while True:
11000 
      (fname, ftype, fid) = iprot.readFieldBegin()
11001 
      if ftype == TType.STOP:
11002 
        break
11003 
      if fid == 1:
11004 
        if ftype == TType.I64:
3064 chandransh 11005 
          self.orderId = iprot.readI64();
1135 chandransh 11006 
        else:
11007 
          iprot.skip(ftype)
11008 
      elif fid == 2:
3064 chandransh 11009 
        if ftype == TType.STRING:
11010 
          self.invoice_number = iprot.readString();
1135 chandransh 11011 
        else:
11012 
          iprot.skip(ftype)
3064 chandransh 11013 
      elif fid == 3:
4658 mandeep.dh 11014 
        if ftype == TType.STRING:
11015 
          self.serialNumber = iprot.readString();
3064 chandransh 11016 
        else:
11017 
          iprot.skip(ftype)
11018 
      elif fid == 4:
11019 
        if ftype == TType.STRING:
11020 
          self.itemNumber = iprot.readString();
11021 
        else:
11022 
          iprot.skip(ftype)
11023 
      elif fid == 5:
11024 
        if ftype == TType.STRING:
4283 anupam.sin 11025 
          self.billed_by = iprot.readString();
3064 chandransh 11026 
        else:
11027 
          iprot.skip(ftype)
11028 
      elif fid == 6:
11029 
        if ftype == TType.I64:
4283 anupam.sin 11030 
          self.jacketNumber = iprot.readI64();
11031 
        else:
11032 
          iprot.skip(ftype)
11033 
      elif fid == 7:
11034 
        if ftype == TType.I64:
3064 chandransh 11035 
          self.billingType = iprot.readI64();
11036 
        else:
11037 
          iprot.skip(ftype)
4283 anupam.sin 11038 
      elif fid == 8:
11039 
        if ftype == TType.I64:
11040 
          self.vendorId = iprot.readI64();
11041 
        else:
11042 
          iprot.skip(ftype)
4763 rajveer 11043 
      elif fid == 9:
11044 
        if ftype == TType.BOOL:
11045 
          self.authorize = iprot.readBool();
11046 
        else:
11047 
          iprot.skip(ftype)
1246 chandransh 11048 
      else:
11049 
        iprot.skip(ftype)
11050 
      iprot.readFieldEnd()
11051 
    iprot.readStructEnd()
11052 
 
11053 
  def write(self, oprot):
11054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11056 
      return
4283 anupam.sin 11057 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11058 
    if self.orderId is not None:
3064 chandransh 11059 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11060 
      oprot.writeI64(self.orderId)
1246 chandransh 11061 
      oprot.writeFieldEnd()
4283 anupam.sin 11062 
    if self.invoice_number is not None:
11063 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11064 
      oprot.writeString(self.invoice_number)
1246 chandransh 11065 
      oprot.writeFieldEnd()
4658 mandeep.dh 11066 
    if self.serialNumber is not None:
11067 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11068 
      oprot.writeString(self.serialNumber)
3064 chandransh 11069 
      oprot.writeFieldEnd()
3431 rajveer 11070 
    if self.itemNumber is not None:
3064 chandransh 11071 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11072 
      oprot.writeString(self.itemNumber)
11073 
      oprot.writeFieldEnd()
4283 anupam.sin 11074 
    if self.billed_by is not None:
11075 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11076 
      oprot.writeString(self.billed_by)
3064 chandransh 11077 
      oprot.writeFieldEnd()
4283 anupam.sin 11078 
    if self.jacketNumber is not None:
11079 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11080 
      oprot.writeI64(self.jacketNumber)
11081 
      oprot.writeFieldEnd()
3431 rajveer 11082 
    if self.billingType is not None:
4283 anupam.sin 11083 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11084 
      oprot.writeI64(self.billingType)
11085 
      oprot.writeFieldEnd()
4283 anupam.sin 11086 
    if self.vendorId is not None:
11087 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
11088 
      oprot.writeI64(self.vendorId)
11089 
      oprot.writeFieldEnd()
4763 rajveer 11090 
    if self.authorize is not None:
11091 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11092 
      oprot.writeBool(self.authorize)
11093 
      oprot.writeFieldEnd()
1246 chandransh 11094 
    oprot.writeFieldStop()
11095 
    oprot.writeStructEnd()
11096 
 
3431 rajveer 11097 
  def validate(self):
11098 
    return
11099 
 
11100 
 
1246 chandransh 11101 
  def __repr__(self):
11102 
    L = ['%s=%r' % (key, value)
11103 
      for key, value in self.__dict__.iteritems()]
11104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11105 
 
11106 
  def __eq__(self, other):
11107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11108 
 
11109 
  def __ne__(self, other):
11110 
    return not (self == other)
11111 
 
4283 anupam.sin 11112 
class addBillingDetails_result:
1246 chandransh 11113 
  """
11114 
  Attributes:
3064 chandransh 11115 
   - success
1246 chandransh 11116 
   - ex
11117 
  """
11118 
 
11119 
  thrift_spec = (
3064 chandransh 11120 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11122 
  )
11123 
 
3064 chandransh 11124 
  def __init__(self, success=None, ex=None,):
11125 
    self.success = success
1246 chandransh 11126 
    self.ex = ex
11127 
 
11128 
  def read(self, iprot):
11129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11131 
      return
11132 
    iprot.readStructBegin()
11133 
    while True:
11134 
      (fname, ftype, fid) = iprot.readFieldBegin()
11135 
      if ftype == TType.STOP:
11136 
        break
3064 chandransh 11137 
      if fid == 0:
11138 
        if ftype == TType.BOOL:
11139 
          self.success = iprot.readBool();
11140 
        else:
11141 
          iprot.skip(ftype)
11142 
      elif fid == 1:
1246 chandransh 11143 
        if ftype == TType.STRUCT:
11144 
          self.ex = TransactionServiceException()
11145 
          self.ex.read(iprot)
11146 
        else:
11147 
          iprot.skip(ftype)
11148 
      else:
11149 
        iprot.skip(ftype)
11150 
      iprot.readFieldEnd()
11151 
    iprot.readStructEnd()
11152 
 
11153 
  def write(self, oprot):
11154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11156 
      return
4283 anupam.sin 11157 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11158 
    if self.success is not None:
3064 chandransh 11159 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11160 
      oprot.writeBool(self.success)
11161 
      oprot.writeFieldEnd()
3431 rajveer 11162 
    if self.ex is not None:
1246 chandransh 11163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11164 
      self.ex.write(oprot)
11165 
      oprot.writeFieldEnd()
11166 
    oprot.writeFieldStop()
11167 
    oprot.writeStructEnd()
11168 
 
3431 rajveer 11169 
  def validate(self):
11170 
    return
11171 
 
11172 
 
1246 chandransh 11173 
  def __repr__(self):
11174 
    L = ['%s=%r' % (key, value)
11175 
      for key, value in self.__dict__.iteritems()]
11176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11177 
 
11178 
  def __eq__(self, other):
11179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11180 
 
11181 
  def __ne__(self, other):
11182 
    return not (self == other)
11183 
 
4579 rajveer 11184 
class addInvoiceNumber_args:
11185 
  """
11186 
  Attributes:
11187 
   - orderId
11188 
   - invoiceNumber
4763 rajveer 11189 
   - color
4579 rajveer 11190 
  """
11191 
 
11192 
  thrift_spec = (
11193 
    None, # 0
11194 
    (1, TType.I64, 'orderId', None, None, ), # 1
11195 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11196 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11197 
  )
11198 
 
4763 rajveer 11199 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11200 
    self.orderId = orderId
11201 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11202 
    self.color = color
4579 rajveer 11203 
 
11204 
  def read(self, iprot):
11205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11207 
      return
11208 
    iprot.readStructBegin()
11209 
    while True:
11210 
      (fname, ftype, fid) = iprot.readFieldBegin()
11211 
      if ftype == TType.STOP:
11212 
        break
11213 
      if fid == 1:
11214 
        if ftype == TType.I64:
11215 
          self.orderId = iprot.readI64();
11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      elif fid == 2:
11219 
        if ftype == TType.STRING:
11220 
          self.invoiceNumber = iprot.readString();
11221 
        else:
11222 
          iprot.skip(ftype)
4763 rajveer 11223 
      elif fid == 3:
11224 
        if ftype == TType.STRING:
11225 
          self.color = iprot.readString();
11226 
        else:
11227 
          iprot.skip(ftype)
4579 rajveer 11228 
      else:
11229 
        iprot.skip(ftype)
11230 
      iprot.readFieldEnd()
11231 
    iprot.readStructEnd()
11232 
 
11233 
  def write(self, oprot):
11234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11236 
      return
11237 
    oprot.writeStructBegin('addInvoiceNumber_args')
11238 
    if self.orderId is not None:
11239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11240 
      oprot.writeI64(self.orderId)
11241 
      oprot.writeFieldEnd()
11242 
    if self.invoiceNumber is not None:
11243 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11244 
      oprot.writeString(self.invoiceNumber)
11245 
      oprot.writeFieldEnd()
4763 rajveer 11246 
    if self.color is not None:
11247 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11248 
      oprot.writeString(self.color)
11249 
      oprot.writeFieldEnd()
4579 rajveer 11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
11253 
  def validate(self):
11254 
    return
11255 
 
11256 
 
11257 
  def __repr__(self):
11258 
    L = ['%s=%r' % (key, value)
11259 
      for key, value in self.__dict__.iteritems()]
11260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11261 
 
11262 
  def __eq__(self, other):
11263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11264 
 
11265 
  def __ne__(self, other):
11266 
    return not (self == other)
11267 
 
11268 
class addInvoiceNumber_result:
11269 
  """
11270 
  Attributes:
11271 
   - ex
11272 
  """
11273 
 
11274 
  thrift_spec = (
11275 
    None, # 0
11276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11277 
  )
11278 
 
11279 
  def __init__(self, ex=None,):
11280 
    self.ex = ex
11281 
 
11282 
  def read(self, iprot):
11283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11285 
      return
11286 
    iprot.readStructBegin()
11287 
    while True:
11288 
      (fname, ftype, fid) = iprot.readFieldBegin()
11289 
      if ftype == TType.STOP:
11290 
        break
11291 
      if fid == 1:
11292 
        if ftype == TType.STRUCT:
11293 
          self.ex = TransactionServiceException()
11294 
          self.ex.read(iprot)
11295 
        else:
11296 
          iprot.skip(ftype)
11297 
      else:
11298 
        iprot.skip(ftype)
11299 
      iprot.readFieldEnd()
11300 
    iprot.readStructEnd()
11301 
 
11302 
  def write(self, oprot):
11303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11305 
      return
11306 
    oprot.writeStructBegin('addInvoiceNumber_result')
11307 
    if self.ex is not None:
11308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11309 
      self.ex.write(oprot)
11310 
      oprot.writeFieldEnd()
11311 
    oprot.writeFieldStop()
11312 
    oprot.writeStructEnd()
11313 
 
11314 
  def validate(self):
11315 
    return
11316 
 
11317 
 
11318 
  def __repr__(self):
11319 
    L = ['%s=%r' % (key, value)
11320 
      for key, value in self.__dict__.iteritems()]
11321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11322 
 
11323 
  def __eq__(self, other):
11324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11325 
 
11326 
  def __ne__(self, other):
11327 
    return not (self == other)
11328 
 
4910 phani.kuma 11329 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11330 
  """
11331 
  Attributes:
3064 chandransh 11332 
   - warehouseId
1408 ankur.sing 11333 
   - providerId
3064 chandransh 11334 
   - cod
4910 phani.kuma 11335 
   - orderIds
1408 ankur.sing 11336 
  """
11337 
 
11338 
  thrift_spec = (
11339 
    None, # 0
3064 chandransh 11340 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11341 
    (2, TType.I64, 'providerId', None, None, ), # 2
11342 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11343 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11344 
  )
11345 
 
4910 phani.kuma 11346 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11347 
    self.warehouseId = warehouseId
1408 ankur.sing 11348 
    self.providerId = providerId
3064 chandransh 11349 
    self.cod = cod
4910 phani.kuma 11350 
    self.orderIds = orderIds
1408 ankur.sing 11351 
 
11352 
  def read(self, iprot):
11353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11355 
      return
11356 
    iprot.readStructBegin()
11357 
    while True:
11358 
      (fname, ftype, fid) = iprot.readFieldBegin()
11359 
      if ftype == TType.STOP:
11360 
        break
11361 
      if fid == 1:
11362 
        if ftype == TType.I64:
3064 chandransh 11363 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11364 
        else:
11365 
          iprot.skip(ftype)
11366 
      elif fid == 2:
11367 
        if ftype == TType.I64:
3064 chandransh 11368 
          self.providerId = iprot.readI64();
1408 ankur.sing 11369 
        else:
11370 
          iprot.skip(ftype)
3064 chandransh 11371 
      elif fid == 3:
11372 
        if ftype == TType.BOOL:
11373 
          self.cod = iprot.readBool();
11374 
        else:
11375 
          iprot.skip(ftype)
4910 phani.kuma 11376 
      elif fid == 4:
11377 
        if ftype == TType.LIST:
11378 
          self.orderIds = []
11379 
          (_etype178, _size175) = iprot.readListBegin()
11380 
          for _i179 in xrange(_size175):
11381 
            _elem180 = iprot.readI64();
11382 
            self.orderIds.append(_elem180)
11383 
          iprot.readListEnd()
11384 
        else:
11385 
          iprot.skip(ftype)
1408 ankur.sing 11386 
      else:
11387 
        iprot.skip(ftype)
11388 
      iprot.readFieldEnd()
11389 
    iprot.readStructEnd()
11390 
 
11391 
  def write(self, oprot):
11392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11394 
      return
4910 phani.kuma 11395 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11396 
    if self.warehouseId is not None:
3064 chandransh 11397 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11398 
      oprot.writeI64(self.warehouseId)
11399 
      oprot.writeFieldEnd()
3431 rajveer 11400 
    if self.providerId is not None:
3064 chandransh 11401 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11402 
      oprot.writeI64(self.providerId)
11403 
      oprot.writeFieldEnd()
3431 rajveer 11404 
    if self.cod is not None:
3064 chandransh 11405 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11406 
      oprot.writeBool(self.cod)
1408 ankur.sing 11407 
      oprot.writeFieldEnd()
4910 phani.kuma 11408 
    if self.orderIds is not None:
11409 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11410 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
11411 
      for iter181 in self.orderIds:
11412 
        oprot.writeI64(iter181)
11413 
      oprot.writeListEnd()
11414 
      oprot.writeFieldEnd()
1408 ankur.sing 11415 
    oprot.writeFieldStop()
11416 
    oprot.writeStructEnd()
11417 
 
3431 rajveer 11418 
  def validate(self):
11419 
    return
11420 
 
11421 
 
1408 ankur.sing 11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
4910 phani.kuma 11433 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11434 
  """
11435 
  Attributes:
11436 
   - success
3064 chandransh 11437 
   - ex
1408 ankur.sing 11438 
  """
11439 
 
11440 
  thrift_spec = (
3064 chandransh 11441 
    (0, TType.BOOL, 'success', None, None, ), # 0
11442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11443 
  )
11444 
 
3064 chandransh 11445 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11446 
    self.success = success
3064 chandransh 11447 
    self.ex = ex
1408 ankur.sing 11448 
 
11449 
  def read(self, iprot):
11450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11452 
      return
11453 
    iprot.readStructBegin()
11454 
    while True:
11455 
      (fname, ftype, fid) = iprot.readFieldBegin()
11456 
      if ftype == TType.STOP:
11457 
        break
11458 
      if fid == 0:
3064 chandransh 11459 
        if ftype == TType.BOOL:
11460 
          self.success = iprot.readBool();
1408 ankur.sing 11461 
        else:
11462 
          iprot.skip(ftype)
3064 chandransh 11463 
      elif fid == 1:
11464 
        if ftype == TType.STRUCT:
11465 
          self.ex = TransactionServiceException()
11466 
          self.ex.read(iprot)
11467 
        else:
11468 
          iprot.skip(ftype)
1408 ankur.sing 11469 
      else:
11470 
        iprot.skip(ftype)
11471 
      iprot.readFieldEnd()
11472 
    iprot.readStructEnd()
11473 
 
11474 
  def write(self, oprot):
11475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11477 
      return
4910 phani.kuma 11478 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11479 
    if self.success is not None:
3064 chandransh 11480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11481 
      oprot.writeBool(self.success)
1408 ankur.sing 11482 
      oprot.writeFieldEnd()
3431 rajveer 11483 
    if self.ex is not None:
3064 chandransh 11484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11485 
      self.ex.write(oprot)
11486 
      oprot.writeFieldEnd()
1408 ankur.sing 11487 
    oprot.writeFieldStop()
11488 
    oprot.writeStructEnd()
11489 
 
3431 rajveer 11490 
  def validate(self):
11491 
    return
11492 
 
11493 
 
1408 ankur.sing 11494 
  def __repr__(self):
11495 
    L = ['%s=%r' % (key, value)
11496 
      for key, value in self.__dict__.iteritems()]
11497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11498 
 
11499 
  def __eq__(self, other):
11500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11501 
 
11502 
  def __ne__(self, other):
11503 
    return not (self == other)
11504 
 
4910 phani.kuma 11505 
class markOrdersAsPickedUp_args:
4410 rajveer 11506 
  """
11507 
  Attributes:
11508 
   - providerId
4910 phani.kuma 11509 
   - pickupDetails
4410 rajveer 11510 
  """
11511 
 
11512 
  thrift_spec = (
11513 
    None, # 0
4910 phani.kuma 11514 
    (1, TType.I64, 'providerId', None, None, ), # 1
11515 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11516 
  )
11517 
 
4910 phani.kuma 11518 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11519 
    self.providerId = providerId
4910 phani.kuma 11520 
    self.pickupDetails = pickupDetails
4410 rajveer 11521 
 
11522 
  def read(self, iprot):
11523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11525 
      return
11526 
    iprot.readStructBegin()
11527 
    while True:
11528 
      (fname, ftype, fid) = iprot.readFieldBegin()
11529 
      if ftype == TType.STOP:
11530 
        break
11531 
      if fid == 1:
11532 
        if ftype == TType.I64:
4910 phani.kuma 11533 
          self.providerId = iprot.readI64();
4410 rajveer 11534 
        else:
11535 
          iprot.skip(ftype)
11536 
      elif fid == 2:
4910 phani.kuma 11537 
        if ftype == TType.MAP:
11538 
          self.pickupDetails = {}
11539 
          (_ktype183, _vtype184, _size182 ) = iprot.readMapBegin()
11540 
          for _i186 in xrange(_size182):
11541 
            _key187 = iprot.readString();
11542 
            _val188 = iprot.readString();
11543 
            self.pickupDetails[_key187] = _val188
11544 
          iprot.readMapEnd()
4410 rajveer 11545 
        else:
11546 
          iprot.skip(ftype)
11547 
      else:
11548 
        iprot.skip(ftype)
11549 
      iprot.readFieldEnd()
11550 
    iprot.readStructEnd()
11551 
 
11552 
  def write(self, oprot):
11553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11555 
      return
4910 phani.kuma 11556 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11557 
    if self.providerId is not None:
4910 phani.kuma 11558 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11559 
      oprot.writeI64(self.providerId)
11560 
      oprot.writeFieldEnd()
4910 phani.kuma 11561 
    if self.pickupDetails is not None:
11562 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11563 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
11564 
      for kiter189,viter190 in self.pickupDetails.items():
11565 
        oprot.writeString(kiter189)
11566 
        oprot.writeString(viter190)
11567 
      oprot.writeMapEnd()
4410 rajveer 11568 
      oprot.writeFieldEnd()
11569 
    oprot.writeFieldStop()
11570 
    oprot.writeStructEnd()
11571 
 
11572 
  def validate(self):
11573 
    return
11574 
 
11575 
 
11576 
  def __repr__(self):
11577 
    L = ['%s=%r' % (key, value)
11578 
      for key, value in self.__dict__.iteritems()]
11579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11580 
 
11581 
  def __eq__(self, other):
11582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11583 
 
11584 
  def __ne__(self, other):
11585 
    return not (self == other)
11586 
 
4910 phani.kuma 11587 
class markOrdersAsPickedUp_result:
4410 rajveer 11588 
  """
11589 
  Attributes:
11590 
   - ex
11591 
  """
11592 
 
11593 
  thrift_spec = (
4910 phani.kuma 11594 
    None, # 0
4410 rajveer 11595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11596 
  )
11597 
 
4910 phani.kuma 11598 
  def __init__(self, ex=None,):
4410 rajveer 11599 
    self.ex = ex
11600 
 
11601 
  def read(self, iprot):
11602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11604 
      return
11605 
    iprot.readStructBegin()
11606 
    while True:
11607 
      (fname, ftype, fid) = iprot.readFieldBegin()
11608 
      if ftype == TType.STOP:
11609 
        break
4910 phani.kuma 11610 
      if fid == 1:
4410 rajveer 11611 
        if ftype == TType.STRUCT:
11612 
          self.ex = TransactionServiceException()
11613 
          self.ex.read(iprot)
11614 
        else:
11615 
          iprot.skip(ftype)
11616 
      else:
11617 
        iprot.skip(ftype)
11618 
      iprot.readFieldEnd()
11619 
    iprot.readStructEnd()
11620 
 
11621 
  def write(self, oprot):
11622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11624 
      return
4910 phani.kuma 11625 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11626 
    if self.ex is not None:
11627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11628 
      self.ex.write(oprot)
11629 
      oprot.writeFieldEnd()
11630 
    oprot.writeFieldStop()
11631 
    oprot.writeStructEnd()
11632 
 
11633 
  def validate(self):
11634 
    return
11635 
 
11636 
 
11637 
  def __repr__(self):
11638 
    L = ['%s=%r' % (key, value)
11639 
      for key, value in self.__dict__.iteritems()]
11640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11641 
 
11642 
  def __eq__(self, other):
11643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11644 
 
11645 
  def __ne__(self, other):
11646 
    return not (self == other)
11647 
 
4910 phani.kuma 11648 
class getOrdersNotPickedUp_args:
304 ashish 11649 
  """
11650 
  Attributes:
3064 chandransh 11651 
   - providerId
304 ashish 11652 
  """
94 ashish 11653 
 
304 ashish 11654 
  thrift_spec = (
11655 
    None, # 0
3064 chandransh 11656 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 11657 
  )
11658 
 
4910 phani.kuma 11659 
  def __init__(self, providerId=None,):
3064 chandransh 11660 
    self.providerId = providerId
304 ashish 11661 
 
11662 
  def read(self, iprot):
11663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11665 
      return
11666 
    iprot.readStructBegin()
11667 
    while True:
11668 
      (fname, ftype, fid) = iprot.readFieldBegin()
11669 
      if ftype == TType.STOP:
11670 
        break
11671 
      if fid == 1:
11672 
        if ftype == TType.I64:
3064 chandransh 11673 
          self.providerId = iprot.readI64();
304 ashish 11674 
        else:
11675 
          iprot.skip(ftype)
11676 
      else:
11677 
        iprot.skip(ftype)
11678 
      iprot.readFieldEnd()
11679 
    iprot.readStructEnd()
11680 
 
11681 
  def write(self, oprot):
11682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11684 
      return
4910 phani.kuma 11685 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 11686 
    if self.providerId is not None:
3064 chandransh 11687 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11688 
      oprot.writeI64(self.providerId)
304 ashish 11689 
      oprot.writeFieldEnd()
11690 
    oprot.writeFieldStop()
11691 
    oprot.writeStructEnd()
11692 
 
3431 rajveer 11693 
  def validate(self):
11694 
    return
11695 
 
11696 
 
304 ashish 11697 
  def __repr__(self):
11698 
    L = ['%s=%r' % (key, value)
11699 
      for key, value in self.__dict__.iteritems()]
11700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11701 
 
11702 
  def __eq__(self, other):
11703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11704 
 
11705 
  def __ne__(self, other):
11706 
    return not (self == other)
11707 
 
4910 phani.kuma 11708 
class getOrdersNotPickedUp_result:
304 ashish 11709 
  """
11710 
  Attributes:
11711 
   - success
11712 
  """
11713 
 
11714 
  thrift_spec = (
3064 chandransh 11715 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 11716 
  )
11717 
 
4910 phani.kuma 11718 
  def __init__(self, success=None,):
304 ashish 11719 
    self.success = success
11720 
 
11721 
  def read(self, iprot):
11722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11724 
      return
11725 
    iprot.readStructBegin()
11726 
    while True:
11727 
      (fname, ftype, fid) = iprot.readFieldBegin()
11728 
      if ftype == TType.STOP:
11729 
        break
11730 
      if fid == 0:
11731 
        if ftype == TType.LIST:
11732 
          self.success = []
4837 varun.gupt 11733 
          (_etype194, _size191) = iprot.readListBegin()
11734 
          for _i195 in xrange(_size191):
11735 
            _elem196 = Order()
11736 
            _elem196.read(iprot)
11737 
            self.success.append(_elem196)
304 ashish 11738 
          iprot.readListEnd()
11739 
        else:
11740 
          iprot.skip(ftype)
11741 
      else:
11742 
        iprot.skip(ftype)
11743 
      iprot.readFieldEnd()
11744 
    iprot.readStructEnd()
11745 
 
11746 
  def write(self, oprot):
11747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11749 
      return
4910 phani.kuma 11750 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 11751 
    if self.success is not None:
304 ashish 11752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11754 
      for iter197 in self.success:
11755 
        iter197.write(oprot)
304 ashish 11756 
      oprot.writeListEnd()
11757 
      oprot.writeFieldEnd()
11758 
    oprot.writeFieldStop()
11759 
    oprot.writeStructEnd()
11760 
 
3431 rajveer 11761 
  def validate(self):
11762 
    return
11763 
 
11764 
 
304 ashish 11765 
  def __repr__(self):
11766 
    L = ['%s=%r' % (key, value)
11767 
      for key, value in self.__dict__.iteritems()]
11768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11769 
 
11770 
  def __eq__(self, other):
11771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11772 
 
11773 
  def __ne__(self, other):
11774 
    return not (self == other)
11775 
 
3064 chandransh 11776 
class markOrdersAsDelivered_args:
304 ashish 11777 
  """
11778 
  Attributes:
3064 chandransh 11779 
   - providerId
11780 
   - deliveredOrders
304 ashish 11781 
  """
11782 
 
11783 
  thrift_spec = (
11784 
    None, # 0
3064 chandransh 11785 
    (1, TType.I64, 'providerId', None, None, ), # 1
11786 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11787 
  )
11788 
 
3064 chandransh 11789 
  def __init__(self, providerId=None, deliveredOrders=None,):
11790 
    self.providerId = providerId
11791 
    self.deliveredOrders = deliveredOrders
304 ashish 11792 
 
11793 
  def read(self, iprot):
11794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11796 
      return
11797 
    iprot.readStructBegin()
11798 
    while True:
11799 
      (fname, ftype, fid) = iprot.readFieldBegin()
11800 
      if ftype == TType.STOP:
11801 
        break
11802 
      if fid == 1:
11803 
        if ftype == TType.I64:
3064 chandransh 11804 
          self.providerId = iprot.readI64();
304 ashish 11805 
        else:
11806 
          iprot.skip(ftype)
11807 
      elif fid == 2:
3064 chandransh 11808 
        if ftype == TType.MAP:
11809 
          self.deliveredOrders = {}
4837 varun.gupt 11810 
          (_ktype199, _vtype200, _size198 ) = iprot.readMapBegin()
11811 
          for _i202 in xrange(_size198):
11812 
            _key203 = iprot.readString();
11813 
            _val204 = iprot.readString();
11814 
            self.deliveredOrders[_key203] = _val204
3064 chandransh 11815 
          iprot.readMapEnd()
304 ashish 11816 
        else:
11817 
          iprot.skip(ftype)
11818 
      else:
11819 
        iprot.skip(ftype)
11820 
      iprot.readFieldEnd()
11821 
    iprot.readStructEnd()
11822 
 
11823 
  def write(self, oprot):
11824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11826 
      return
3064 chandransh 11827 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11828 
    if self.providerId is not None:
3064 chandransh 11829 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11830 
      oprot.writeI64(self.providerId)
304 ashish 11831 
      oprot.writeFieldEnd()
3431 rajveer 11832 
    if self.deliveredOrders is not None:
3064 chandransh 11833 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11834 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4837 varun.gupt 11835 
      for kiter205,viter206 in self.deliveredOrders.items():
11836 
        oprot.writeString(kiter205)
11837 
        oprot.writeString(viter206)
3064 chandransh 11838 
      oprot.writeMapEnd()
304 ashish 11839 
      oprot.writeFieldEnd()
11840 
    oprot.writeFieldStop()
11841 
    oprot.writeStructEnd()
11842 
 
3431 rajveer 11843 
  def validate(self):
11844 
    return
11845 
 
11846 
 
304 ashish 11847 
  def __repr__(self):
11848 
    L = ['%s=%r' % (key, value)
11849 
      for key, value in self.__dict__.iteritems()]
11850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11851 
 
11852 
  def __eq__(self, other):
11853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11854 
 
11855 
  def __ne__(self, other):
11856 
    return not (self == other)
11857 
 
3064 chandransh 11858 
class markOrdersAsDelivered_result:
11859 
  """
11860 
  Attributes:
11861 
   - ex
11862 
  """
304 ashish 11863 
 
11864 
  thrift_spec = (
3064 chandransh 11865 
    None, # 0
11866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11867 
  )
11868 
 
3064 chandransh 11869 
  def __init__(self, ex=None,):
11870 
    self.ex = ex
304 ashish 11871 
 
1596 ankur.sing 11872 
  def read(self, iprot):
11873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11875 
      return
11876 
    iprot.readStructBegin()
11877 
    while True:
11878 
      (fname, ftype, fid) = iprot.readFieldBegin()
11879 
      if ftype == TType.STOP:
11880 
        break
3064 chandransh 11881 
      if fid == 1:
11882 
        if ftype == TType.STRUCT:
11883 
          self.ex = TransactionServiceException()
11884 
          self.ex.read(iprot)
11885 
        else:
11886 
          iprot.skip(ftype)
1596 ankur.sing 11887 
      else:
11888 
        iprot.skip(ftype)
11889 
      iprot.readFieldEnd()
11890 
    iprot.readStructEnd()
11891 
 
11892 
  def write(self, oprot):
11893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11895 
      return
3064 chandransh 11896 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11897 
    if self.ex is not None:
3064 chandransh 11898 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11899 
      self.ex.write(oprot)
11900 
      oprot.writeFieldEnd()
1596 ankur.sing 11901 
    oprot.writeFieldStop()
11902 
    oprot.writeStructEnd()
11903 
 
3431 rajveer 11904 
  def validate(self):
11905 
    return
11906 
 
11907 
 
1596 ankur.sing 11908 
  def __repr__(self):
11909 
    L = ['%s=%r' % (key, value)
11910 
      for key, value in self.__dict__.iteritems()]
11911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11912 
 
11913 
  def __eq__(self, other):
11914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11915 
 
11916 
  def __ne__(self, other):
11917 
    return not (self == other)
11918 
 
4910 phani.kuma 11919 
class markAsRTOrders_args:
1596 ankur.sing 11920 
  """
11921 
  Attributes:
3064 chandransh 11922 
   - providerId
11923 
   - returnedOrders
1596 ankur.sing 11924 
  """
11925 
 
11926 
  thrift_spec = (
3064 chandransh 11927 
    None, # 0
11928 
    (1, TType.I64, 'providerId', None, None, ), # 1
11929 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11930 
  )
11931 
 
3064 chandransh 11932 
  def __init__(self, providerId=None, returnedOrders=None,):
11933 
    self.providerId = providerId
11934 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
3064 chandransh 11945 
      if fid == 1:
1596 ankur.sing 11946 
        if ftype == TType.I64:
3064 chandransh 11947 
          self.providerId = iprot.readI64();
1596 ankur.sing 11948 
        else:
11949 
          iprot.skip(ftype)
3064 chandransh 11950 
      elif fid == 2:
11951 
        if ftype == TType.MAP:
11952 
          self.returnedOrders = {}
4837 varun.gupt 11953 
          (_ktype208, _vtype209, _size207 ) = iprot.readMapBegin()
11954 
          for _i211 in xrange(_size207):
11955 
            _key212 = iprot.readString();
11956 
            _val213 = iprot.readString();
11957 
            self.returnedOrders[_key212] = _val213
3064 chandransh 11958 
          iprot.readMapEnd()
11959 
        else:
11960 
          iprot.skip(ftype)
1596 ankur.sing 11961 
      else:
11962 
        iprot.skip(ftype)
11963 
      iprot.readFieldEnd()
11964 
    iprot.readStructEnd()
11965 
 
11966 
  def write(self, oprot):
11967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11969 
      return
4910 phani.kuma 11970 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 11971 
    if self.providerId is not None:
3064 chandransh 11972 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11973 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11974 
      oprot.writeFieldEnd()
3431 rajveer 11975 
    if self.returnedOrders is not None:
3064 chandransh 11976 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11977 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4837 varun.gupt 11978 
      for kiter214,viter215 in self.returnedOrders.items():
11979 
        oprot.writeString(kiter214)
11980 
        oprot.writeString(viter215)
3064 chandransh 11981 
      oprot.writeMapEnd()
11982 
      oprot.writeFieldEnd()
1596 ankur.sing 11983 
    oprot.writeFieldStop()
11984 
    oprot.writeStructEnd()
11985 
 
3431 rajveer 11986 
  def validate(self):
11987 
    return
11988 
 
11989 
 
1596 ankur.sing 11990 
  def __repr__(self):
11991 
    L = ['%s=%r' % (key, value)
11992 
      for key, value in self.__dict__.iteritems()]
11993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11994 
 
11995 
  def __eq__(self, other):
11996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11997 
 
11998 
  def __ne__(self, other):
11999 
    return not (self == other)
12000 
 
4910 phani.kuma 12001 
class markAsRTOrders_result:
3064 chandransh 12002 
  """
12003 
  Attributes:
12004 
   - ex
12005 
  """
1596 ankur.sing 12006 
 
1627 ankur.sing 12007 
  thrift_spec = (
3064 chandransh 12008 
    None, # 0
12009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12010 
  )
12011 
 
3064 chandransh 12012 
  def __init__(self, ex=None,):
12013 
    self.ex = ex
12014 
 
1627 ankur.sing 12015 
  def read(self, iprot):
12016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12018 
      return
12019 
    iprot.readStructBegin()
12020 
    while True:
12021 
      (fname, ftype, fid) = iprot.readFieldBegin()
12022 
      if ftype == TType.STOP:
12023 
        break
3064 chandransh 12024 
      if fid == 1:
12025 
        if ftype == TType.STRUCT:
12026 
          self.ex = TransactionServiceException()
12027 
          self.ex.read(iprot)
12028 
        else:
12029 
          iprot.skip(ftype)
1627 ankur.sing 12030 
      else:
12031 
        iprot.skip(ftype)
12032 
      iprot.readFieldEnd()
12033 
    iprot.readStructEnd()
12034 
 
12035 
  def write(self, oprot):
12036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12038 
      return
4910 phani.kuma 12039 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12040 
    if self.ex is not None:
3064 chandransh 12041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12042 
      self.ex.write(oprot)
12043 
      oprot.writeFieldEnd()
1627 ankur.sing 12044 
    oprot.writeFieldStop()
12045 
    oprot.writeStructEnd()
12046 
 
3431 rajveer 12047 
  def validate(self):
12048 
    return
12049 
 
12050 
 
1627 ankur.sing 12051 
  def __repr__(self):
12052 
    L = ['%s=%r' % (key, value)
12053 
      for key, value in self.__dict__.iteritems()]
12054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12055 
 
12056 
  def __eq__(self, other):
12057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12058 
 
12059 
  def __ne__(self, other):
12060 
    return not (self == other)
12061 
 
4910 phani.kuma 12062 
class getRTOrders_args:
12063 
  """
12064 
  Attributes:
12065 
   - providerId
12066 
  """
12067 
 
12068 
  thrift_spec = (
12069 
    None, # 0
12070 
    (1, TType.I64, 'providerId', None, None, ), # 1
12071 
  )
12072 
 
12073 
  def __init__(self, providerId=None,):
12074 
    self.providerId = providerId
12075 
 
12076 
  def read(self, iprot):
12077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12079 
      return
12080 
    iprot.readStructBegin()
12081 
    while True:
12082 
      (fname, ftype, fid) = iprot.readFieldBegin()
12083 
      if ftype == TType.STOP:
12084 
        break
12085 
      if fid == 1:
12086 
        if ftype == TType.I64:
12087 
          self.providerId = iprot.readI64();
12088 
        else:
12089 
          iprot.skip(ftype)
12090 
      else:
12091 
        iprot.skip(ftype)
12092 
      iprot.readFieldEnd()
12093 
    iprot.readStructEnd()
12094 
 
12095 
  def write(self, oprot):
12096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12098 
      return
12099 
    oprot.writeStructBegin('getRTOrders_args')
12100 
    if self.providerId is not None:
12101 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12102 
      oprot.writeI64(self.providerId)
12103 
      oprot.writeFieldEnd()
12104 
    oprot.writeFieldStop()
12105 
    oprot.writeStructEnd()
12106 
 
12107 
  def validate(self):
12108 
    return
12109 
 
12110 
 
12111 
  def __repr__(self):
12112 
    L = ['%s=%r' % (key, value)
12113 
      for key, value in self.__dict__.iteritems()]
12114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12115 
 
12116 
  def __eq__(self, other):
12117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12118 
 
12119 
  def __ne__(self, other):
12120 
    return not (self == other)
12121 
 
12122 
class getRTOrders_result:
12123 
  """
12124 
  Attributes:
12125 
   - success
12126 
  """
12127 
 
12128 
  thrift_spec = (
12129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12130 
  )
12131 
 
12132 
  def __init__(self, success=None,):
12133 
    self.success = success
12134 
 
12135 
  def read(self, iprot):
12136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12138 
      return
12139 
    iprot.readStructBegin()
12140 
    while True:
12141 
      (fname, ftype, fid) = iprot.readFieldBegin()
12142 
      if ftype == TType.STOP:
12143 
        break
12144 
      if fid == 0:
12145 
        if ftype == TType.LIST:
12146 
          self.success = []
12147 
          (_etype219, _size216) = iprot.readListBegin()
12148 
          for _i220 in xrange(_size216):
12149 
            _elem221 = Order()
12150 
            _elem221.read(iprot)
12151 
            self.success.append(_elem221)
12152 
          iprot.readListEnd()
12153 
        else:
12154 
          iprot.skip(ftype)
12155 
      else:
12156 
        iprot.skip(ftype)
12157 
      iprot.readFieldEnd()
12158 
    iprot.readStructEnd()
12159 
 
12160 
  def write(self, oprot):
12161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12163 
      return
12164 
    oprot.writeStructBegin('getRTOrders_result')
12165 
    if self.success is not None:
12166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12168 
      for iter222 in self.success:
12169 
        iter222.write(oprot)
12170 
      oprot.writeListEnd()
12171 
      oprot.writeFieldEnd()
12172 
    oprot.writeFieldStop()
12173 
    oprot.writeStructEnd()
12174 
 
12175 
  def validate(self):
12176 
    return
12177 
 
12178 
 
12179 
  def __repr__(self):
12180 
    L = ['%s=%r' % (key, value)
12181 
      for key, value in self.__dict__.iteritems()]
12182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12183 
 
12184 
  def __eq__(self, other):
12185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12186 
 
12187 
  def __ne__(self, other):
12188 
    return not (self == other)
12189 
 
3064 chandransh 12190 
class updateNonDeliveryReason_args:
1627 ankur.sing 12191 
  """
12192 
  Attributes:
3064 chandransh 12193 
   - providerId
12194 
   - undeliveredOrders
1627 ankur.sing 12195 
  """
12196 
 
12197 
  thrift_spec = (
3064 chandransh 12198 
    None, # 0
12199 
    (1, TType.I64, 'providerId', None, None, ), # 1
12200 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12201 
  )
12202 
 
3064 chandransh 12203 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12204 
    self.providerId = providerId
12205 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12206 
 
12207 
  def read(self, iprot):
12208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12210 
      return
12211 
    iprot.readStructBegin()
12212 
    while True:
12213 
      (fname, ftype, fid) = iprot.readFieldBegin()
12214 
      if ftype == TType.STOP:
12215 
        break
3064 chandransh 12216 
      if fid == 1:
1627 ankur.sing 12217 
        if ftype == TType.I64:
3064 chandransh 12218 
          self.providerId = iprot.readI64();
1627 ankur.sing 12219 
        else:
12220 
          iprot.skip(ftype)
3064 chandransh 12221 
      elif fid == 2:
12222 
        if ftype == TType.MAP:
12223 
          self.undeliveredOrders = {}
4910 phani.kuma 12224 
          (_ktype224, _vtype225, _size223 ) = iprot.readMapBegin()
12225 
          for _i227 in xrange(_size223):
12226 
            _key228 = iprot.readString();
12227 
            _val229 = iprot.readString();
12228 
            self.undeliveredOrders[_key228] = _val229
3064 chandransh 12229 
          iprot.readMapEnd()
12230 
        else:
12231 
          iprot.skip(ftype)
1627 ankur.sing 12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
3064 chandransh 12241 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12242 
    if self.providerId is not None:
3064 chandransh 12243 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12244 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12245 
      oprot.writeFieldEnd()
3431 rajveer 12246 
    if self.undeliveredOrders is not None:
3064 chandransh 12247 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12248 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4910 phani.kuma 12249 
      for kiter230,viter231 in self.undeliveredOrders.items():
12250 
        oprot.writeString(kiter230)
12251 
        oprot.writeString(viter231)
3064 chandransh 12252 
      oprot.writeMapEnd()
12253 
      oprot.writeFieldEnd()
1627 ankur.sing 12254 
    oprot.writeFieldStop()
12255 
    oprot.writeStructEnd()
12256 
 
3431 rajveer 12257 
  def validate(self):
12258 
    return
12259 
 
12260 
 
1627 ankur.sing 12261 
  def __repr__(self):
12262 
    L = ['%s=%r' % (key, value)
12263 
      for key, value in self.__dict__.iteritems()]
12264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12265 
 
12266 
  def __eq__(self, other):
12267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12268 
 
12269 
  def __ne__(self, other):
12270 
    return not (self == other)
12271 
 
3064 chandransh 12272 
class updateNonDeliveryReason_result:
1627 ankur.sing 12273 
  """
12274 
  Attributes:
3064 chandransh 12275 
   - ex
1627 ankur.sing 12276 
  """
12277 
 
12278 
  thrift_spec = (
4910 phani.kuma 12279 
    None, # 0
3064 chandransh 12280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12281 
  )
12282 
 
4910 phani.kuma 12283 
  def __init__(self, ex=None,):
3064 chandransh 12284 
    self.ex = ex
1627 ankur.sing 12285 
 
12286 
  def read(self, iprot):
12287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12289 
      return
12290 
    iprot.readStructBegin()
12291 
    while True:
12292 
      (fname, ftype, fid) = iprot.readFieldBegin()
12293 
      if ftype == TType.STOP:
12294 
        break
4910 phani.kuma 12295 
      if fid == 1:
12296 
        if ftype == TType.STRUCT:
12297 
          self.ex = TransactionServiceException()
12298 
          self.ex.read(iprot)
12299 
        else:
12300 
          iprot.skip(ftype)
12301 
      else:
12302 
        iprot.skip(ftype)
12303 
      iprot.readFieldEnd()
12304 
    iprot.readStructEnd()
12305 
 
12306 
  def write(self, oprot):
12307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12309 
      return
12310 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12311 
    if self.ex is not None:
12312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12313 
      self.ex.write(oprot)
12314 
      oprot.writeFieldEnd()
12315 
    oprot.writeFieldStop()
12316 
    oprot.writeStructEnd()
12317 
 
12318 
  def validate(self):
12319 
    return
12320 
 
12321 
 
12322 
  def __repr__(self):
12323 
    L = ['%s=%r' % (key, value)
12324 
      for key, value in self.__dict__.iteritems()]
12325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12326 
 
12327 
  def __eq__(self, other):
12328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12329 
 
12330 
  def __ne__(self, other):
12331 
    return not (self == other)
12332 
 
12333 
class getNonDeliveredOrdersbyCourier_args:
12334 
  """
12335 
  Attributes:
12336 
   - providerId
12337 
  """
12338 
 
12339 
  thrift_spec = (
12340 
    None, # 0
12341 
    (1, TType.I64, 'providerId', None, None, ), # 1
12342 
  )
12343 
 
12344 
  def __init__(self, providerId=None,):
12345 
    self.providerId = providerId
12346 
 
12347 
  def read(self, iprot):
12348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12350 
      return
12351 
    iprot.readStructBegin()
12352 
    while True:
12353 
      (fname, ftype, fid) = iprot.readFieldBegin()
12354 
      if ftype == TType.STOP:
12355 
        break
12356 
      if fid == 1:
12357 
        if ftype == TType.I64:
12358 
          self.providerId = iprot.readI64();
12359 
        else:
12360 
          iprot.skip(ftype)
12361 
      else:
12362 
        iprot.skip(ftype)
12363 
      iprot.readFieldEnd()
12364 
    iprot.readStructEnd()
12365 
 
12366 
  def write(self, oprot):
12367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12369 
      return
12370 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12371 
    if self.providerId is not None:
12372 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12373 
      oprot.writeI64(self.providerId)
12374 
      oprot.writeFieldEnd()
12375 
    oprot.writeFieldStop()
12376 
    oprot.writeStructEnd()
12377 
 
12378 
  def validate(self):
12379 
    return
12380 
 
12381 
 
12382 
  def __repr__(self):
12383 
    L = ['%s=%r' % (key, value)
12384 
      for key, value in self.__dict__.iteritems()]
12385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12386 
 
12387 
  def __eq__(self, other):
12388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12389 
 
12390 
  def __ne__(self, other):
12391 
    return not (self == other)
12392 
 
12393 
class getNonDeliveredOrdersbyCourier_result:
12394 
  """
12395 
  Attributes:
12396 
   - success
12397 
  """
12398 
 
12399 
  thrift_spec = (
12400 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12401 
  )
12402 
 
12403 
  def __init__(self, success=None,):
12404 
    self.success = success
12405 
 
12406 
  def read(self, iprot):
12407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12409 
      return
12410 
    iprot.readStructBegin()
12411 
    while True:
12412 
      (fname, ftype, fid) = iprot.readFieldBegin()
12413 
      if ftype == TType.STOP:
12414 
        break
4581 phani.kuma 12415 
      if fid == 0:
12416 
        if ftype == TType.LIST:
12417 
          self.success = []
4910 phani.kuma 12418 
          (_etype235, _size232) = iprot.readListBegin()
12419 
          for _i236 in xrange(_size232):
12420 
            _elem237 = Order()
12421 
            _elem237.read(iprot)
12422 
            self.success.append(_elem237)
4581 phani.kuma 12423 
          iprot.readListEnd()
12424 
        else:
12425 
          iprot.skip(ftype)
4910 phani.kuma 12426 
      else:
12427 
        iprot.skip(ftype)
12428 
      iprot.readFieldEnd()
12429 
    iprot.readStructEnd()
12430 
 
12431 
  def write(self, oprot):
12432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12434 
      return
12435 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12436 
    if self.success is not None:
12437 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12438 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12439 
      for iter238 in self.success:
12440 
        iter238.write(oprot)
12441 
      oprot.writeListEnd()
12442 
      oprot.writeFieldEnd()
12443 
    oprot.writeFieldStop()
12444 
    oprot.writeStructEnd()
12445 
 
12446 
  def validate(self):
12447 
    return
12448 
 
12449 
 
12450 
  def __repr__(self):
12451 
    L = ['%s=%r' % (key, value)
12452 
      for key, value in self.__dict__.iteritems()]
12453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12454 
 
12455 
  def __eq__(self, other):
12456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12457 
 
12458 
  def __ne__(self, other):
12459 
    return not (self == other)
12460 
 
12461 
class markOrdersAsLocalConnected_args:
12462 
  """
12463 
  Attributes:
12464 
   - providerId
12465 
   - local_connected_orders
12466 
  """
12467 
 
12468 
  thrift_spec = (
12469 
    None, # 0
12470 
    (1, TType.I64, 'providerId', None, None, ), # 1
12471 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12472 
  )
12473 
 
12474 
  def __init__(self, providerId=None, local_connected_orders=None,):
12475 
    self.providerId = providerId
12476 
    self.local_connected_orders = local_connected_orders
12477 
 
12478 
  def read(self, iprot):
12479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12481 
      return
12482 
    iprot.readStructBegin()
12483 
    while True:
12484 
      (fname, ftype, fid) = iprot.readFieldBegin()
12485 
      if ftype == TType.STOP:
12486 
        break
12487 
      if fid == 1:
12488 
        if ftype == TType.I64:
12489 
          self.providerId = iprot.readI64();
12490 
        else:
12491 
          iprot.skip(ftype)
12492 
      elif fid == 2:
12493 
        if ftype == TType.MAP:
12494 
          self.local_connected_orders = {}
12495 
          (_ktype240, _vtype241, _size239 ) = iprot.readMapBegin()
12496 
          for _i243 in xrange(_size239):
12497 
            _key244 = iprot.readString();
12498 
            _val245 = iprot.readString();
12499 
            self.local_connected_orders[_key244] = _val245
12500 
          iprot.readMapEnd()
12501 
        else:
12502 
          iprot.skip(ftype)
12503 
      else:
12504 
        iprot.skip(ftype)
12505 
      iprot.readFieldEnd()
12506 
    iprot.readStructEnd()
12507 
 
12508 
  def write(self, oprot):
12509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12511 
      return
12512 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12513 
    if self.providerId is not None:
12514 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12515 
      oprot.writeI64(self.providerId)
12516 
      oprot.writeFieldEnd()
12517 
    if self.local_connected_orders is not None:
12518 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12519 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
12520 
      for kiter246,viter247 in self.local_connected_orders.items():
12521 
        oprot.writeString(kiter246)
12522 
        oprot.writeString(viter247)
12523 
      oprot.writeMapEnd()
12524 
      oprot.writeFieldEnd()
12525 
    oprot.writeFieldStop()
12526 
    oprot.writeStructEnd()
12527 
 
12528 
  def validate(self):
12529 
    return
12530 
 
12531 
 
12532 
  def __repr__(self):
12533 
    L = ['%s=%r' % (key, value)
12534 
      for key, value in self.__dict__.iteritems()]
12535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12536 
 
12537 
  def __eq__(self, other):
12538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12539 
 
12540 
  def __ne__(self, other):
12541 
    return not (self == other)
12542 
 
12543 
class markOrdersAsLocalConnected_result:
12544 
  """
12545 
  Attributes:
12546 
   - ex
12547 
  """
12548 
 
12549 
  thrift_spec = (
12550 
    None, # 0
12551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12552 
  )
12553 
 
12554 
  def __init__(self, ex=None,):
12555 
    self.ex = ex
12556 
 
12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
12566 
      if fid == 1:
3064 chandransh 12567 
        if ftype == TType.STRUCT:
12568 
          self.ex = TransactionServiceException()
12569 
          self.ex.read(iprot)
1627 ankur.sing 12570 
        else:
12571 
          iprot.skip(ftype)
12572 
      else:
12573 
        iprot.skip(ftype)
12574 
      iprot.readFieldEnd()
12575 
    iprot.readStructEnd()
12576 
 
12577 
  def write(self, oprot):
12578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12580 
      return
4910 phani.kuma 12581 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12582 
    if self.ex is not None:
12583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12584 
      self.ex.write(oprot)
12585 
      oprot.writeFieldEnd()
12586 
    oprot.writeFieldStop()
12587 
    oprot.writeStructEnd()
12588 
 
12589 
  def validate(self):
12590 
    return
12591 
 
12592 
 
12593 
  def __repr__(self):
12594 
    L = ['%s=%r' % (key, value)
12595 
      for key, value in self.__dict__.iteritems()]
12596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12597 
 
12598 
  def __eq__(self, other):
12599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12600 
 
12601 
  def __ne__(self, other):
12602 
    return not (self == other)
12603 
 
12604 
class getOrdersNotLocalConnected_args:
12605 
  """
12606 
  Attributes:
12607 
   - providerId
12608 
  """
12609 
 
12610 
  thrift_spec = (
12611 
    None, # 0
12612 
    (1, TType.I64, 'providerId', None, None, ), # 1
12613 
  )
12614 
 
12615 
  def __init__(self, providerId=None,):
12616 
    self.providerId = providerId
12617 
 
12618 
  def read(self, iprot):
12619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12621 
      return
12622 
    iprot.readStructBegin()
12623 
    while True:
12624 
      (fname, ftype, fid) = iprot.readFieldBegin()
12625 
      if ftype == TType.STOP:
12626 
        break
12627 
      if fid == 1:
12628 
        if ftype == TType.I64:
12629 
          self.providerId = iprot.readI64();
12630 
        else:
12631 
          iprot.skip(ftype)
12632 
      else:
12633 
        iprot.skip(ftype)
12634 
      iprot.readFieldEnd()
12635 
    iprot.readStructEnd()
12636 
 
12637 
  def write(self, oprot):
12638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12640 
      return
12641 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12642 
    if self.providerId is not None:
12643 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12644 
      oprot.writeI64(self.providerId)
12645 
      oprot.writeFieldEnd()
12646 
    oprot.writeFieldStop()
12647 
    oprot.writeStructEnd()
12648 
 
12649 
  def validate(self):
12650 
    return
12651 
 
12652 
 
12653 
  def __repr__(self):
12654 
    L = ['%s=%r' % (key, value)
12655 
      for key, value in self.__dict__.iteritems()]
12656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12657 
 
12658 
  def __eq__(self, other):
12659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12660 
 
12661 
  def __ne__(self, other):
12662 
    return not (self == other)
12663 
 
12664 
class getOrdersNotLocalConnected_result:
12665 
  """
12666 
  Attributes:
12667 
   - success
12668 
  """
12669 
 
12670 
  thrift_spec = (
12671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12672 
  )
12673 
 
12674 
  def __init__(self, success=None,):
12675 
    self.success = success
12676 
 
12677 
  def read(self, iprot):
12678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12680 
      return
12681 
    iprot.readStructBegin()
12682 
    while True:
12683 
      (fname, ftype, fid) = iprot.readFieldBegin()
12684 
      if ftype == TType.STOP:
12685 
        break
12686 
      if fid == 0:
12687 
        if ftype == TType.LIST:
12688 
          self.success = []
12689 
          (_etype251, _size248) = iprot.readListBegin()
12690 
          for _i252 in xrange(_size248):
12691 
            _elem253 = Order()
12692 
            _elem253.read(iprot)
12693 
            self.success.append(_elem253)
12694 
          iprot.readListEnd()
12695 
        else:
12696 
          iprot.skip(ftype)
12697 
      else:
12698 
        iprot.skip(ftype)
12699 
      iprot.readFieldEnd()
12700 
    iprot.readStructEnd()
12701 
 
12702 
  def write(self, oprot):
12703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12705 
      return
12706 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 12707 
    if self.success is not None:
12708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12709 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 12710 
      for iter254 in self.success:
12711 
        iter254.write(oprot)
4581 phani.kuma 12712 
      oprot.writeListEnd()
12713 
      oprot.writeFieldEnd()
4910 phani.kuma 12714 
    oprot.writeFieldStop()
12715 
    oprot.writeStructEnd()
12716 
 
12717 
  def validate(self):
12718 
    return
12719 
 
12720 
 
12721 
  def __repr__(self):
12722 
    L = ['%s=%r' % (key, value)
12723 
      for key, value in self.__dict__.iteritems()]
12724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12725 
 
12726 
  def __eq__(self, other):
12727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12728 
 
12729 
  def __ne__(self, other):
12730 
    return not (self == other)
12731 
 
12732 
class markOrdersAsDestinationCityReached_args:
12733 
  """
12734 
  Attributes:
12735 
   - providerId
12736 
   - destination_city_reached_orders
12737 
  """
12738 
 
12739 
  thrift_spec = (
12740 
    None, # 0
12741 
    (1, TType.I64, 'providerId', None, None, ), # 1
12742 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12743 
  )
12744 
 
12745 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
12746 
    self.providerId = providerId
12747 
    self.destination_city_reached_orders = destination_city_reached_orders
12748 
 
12749 
  def read(self, iprot):
12750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12752 
      return
12753 
    iprot.readStructBegin()
12754 
    while True:
12755 
      (fname, ftype, fid) = iprot.readFieldBegin()
12756 
      if ftype == TType.STOP:
12757 
        break
12758 
      if fid == 1:
12759 
        if ftype == TType.I64:
12760 
          self.providerId = iprot.readI64();
12761 
        else:
12762 
          iprot.skip(ftype)
12763 
      elif fid == 2:
12764 
        if ftype == TType.MAP:
12765 
          self.destination_city_reached_orders = {}
12766 
          (_ktype256, _vtype257, _size255 ) = iprot.readMapBegin()
12767 
          for _i259 in xrange(_size255):
12768 
            _key260 = iprot.readString();
12769 
            _val261 = iprot.readString();
12770 
            self.destination_city_reached_orders[_key260] = _val261
12771 
          iprot.readMapEnd()
12772 
        else:
12773 
          iprot.skip(ftype)
12774 
      else:
12775 
        iprot.skip(ftype)
12776 
      iprot.readFieldEnd()
12777 
    iprot.readStructEnd()
12778 
 
12779 
  def write(self, oprot):
12780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12782 
      return
12783 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
12784 
    if self.providerId is not None:
12785 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12786 
      oprot.writeI64(self.providerId)
12787 
      oprot.writeFieldEnd()
12788 
    if self.destination_city_reached_orders is not None:
12789 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
12790 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
12791 
      for kiter262,viter263 in self.destination_city_reached_orders.items():
12792 
        oprot.writeString(kiter262)
12793 
        oprot.writeString(viter263)
12794 
      oprot.writeMapEnd()
12795 
      oprot.writeFieldEnd()
12796 
    oprot.writeFieldStop()
12797 
    oprot.writeStructEnd()
12798 
 
12799 
  def validate(self):
12800 
    return
12801 
 
12802 
 
12803 
  def __repr__(self):
12804 
    L = ['%s=%r' % (key, value)
12805 
      for key, value in self.__dict__.iteritems()]
12806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12807 
 
12808 
  def __eq__(self, other):
12809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12810 
 
12811 
  def __ne__(self, other):
12812 
    return not (self == other)
12813 
 
12814 
class markOrdersAsDestinationCityReached_result:
12815 
  """
12816 
  Attributes:
12817 
   - ex
12818 
  """
12819 
 
12820 
  thrift_spec = (
12821 
    None, # 0
12822 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12823 
  )
12824 
 
12825 
  def __init__(self, ex=None,):
12826 
    self.ex = ex
12827 
 
12828 
  def read(self, iprot):
12829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12831 
      return
12832 
    iprot.readStructBegin()
12833 
    while True:
12834 
      (fname, ftype, fid) = iprot.readFieldBegin()
12835 
      if ftype == TType.STOP:
12836 
        break
12837 
      if fid == 1:
12838 
        if ftype == TType.STRUCT:
12839 
          self.ex = TransactionServiceException()
12840 
          self.ex.read(iprot)
12841 
        else:
12842 
          iprot.skip(ftype)
12843 
      else:
12844 
        iprot.skip(ftype)
12845 
      iprot.readFieldEnd()
12846 
    iprot.readStructEnd()
12847 
 
12848 
  def write(self, oprot):
12849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12851 
      return
12852 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 12853 
    if self.ex is not None:
3064 chandransh 12854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12855 
      self.ex.write(oprot)
1627 ankur.sing 12856 
      oprot.writeFieldEnd()
12857 
    oprot.writeFieldStop()
12858 
    oprot.writeStructEnd()
12859 
 
3431 rajveer 12860 
  def validate(self):
12861 
    return
12862 
 
12863 
 
1627 ankur.sing 12864 
  def __repr__(self):
12865 
    L = ['%s=%r' % (key, value)
12866 
      for key, value in self.__dict__.iteritems()]
12867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12868 
 
12869 
  def __eq__(self, other):
12870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12871 
 
12872 
  def __ne__(self, other):
12873 
    return not (self == other)
12874 
 
4910 phani.kuma 12875 
class markOrdersAsFirstDeliveryAttempted_args:
12876 
  """
12877 
  Attributes:
12878 
   - providerId
12879 
   - first_atdl_orders
12880 
  """
12881 
 
12882 
  thrift_spec = (
12883 
    None, # 0
12884 
    (1, TType.I64, 'providerId', None, None, ), # 1
12885 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12886 
  )
12887 
 
12888 
  def __init__(self, providerId=None, first_atdl_orders=None,):
12889 
    self.providerId = providerId
12890 
    self.first_atdl_orders = first_atdl_orders
12891 
 
12892 
  def read(self, iprot):
12893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12895 
      return
12896 
    iprot.readStructBegin()
12897 
    while True:
12898 
      (fname, ftype, fid) = iprot.readFieldBegin()
12899 
      if ftype == TType.STOP:
12900 
        break
12901 
      if fid == 1:
12902 
        if ftype == TType.I64:
12903 
          self.providerId = iprot.readI64();
12904 
        else:
12905 
          iprot.skip(ftype)
12906 
      elif fid == 2:
12907 
        if ftype == TType.MAP:
12908 
          self.first_atdl_orders = {}
12909 
          (_ktype265, _vtype266, _size264 ) = iprot.readMapBegin()
12910 
          for _i268 in xrange(_size264):
12911 
            _key269 = iprot.readString();
12912 
            _val270 = iprot.readString();
12913 
            self.first_atdl_orders[_key269] = _val270
12914 
          iprot.readMapEnd()
12915 
        else:
12916 
          iprot.skip(ftype)
12917 
      else:
12918 
        iprot.skip(ftype)
12919 
      iprot.readFieldEnd()
12920 
    iprot.readStructEnd()
12921 
 
12922 
  def write(self, oprot):
12923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12925 
      return
12926 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
12927 
    if self.providerId is not None:
12928 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12929 
      oprot.writeI64(self.providerId)
12930 
      oprot.writeFieldEnd()
12931 
    if self.first_atdl_orders is not None:
12932 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
12933 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
12934 
      for kiter271,viter272 in self.first_atdl_orders.items():
12935 
        oprot.writeString(kiter271)
12936 
        oprot.writeString(viter272)
12937 
      oprot.writeMapEnd()
12938 
      oprot.writeFieldEnd()
12939 
    oprot.writeFieldStop()
12940 
    oprot.writeStructEnd()
12941 
 
12942 
  def validate(self):
12943 
    return
12944 
 
12945 
 
12946 
  def __repr__(self):
12947 
    L = ['%s=%r' % (key, value)
12948 
      for key, value in self.__dict__.iteritems()]
12949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12950 
 
12951 
  def __eq__(self, other):
12952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12953 
 
12954 
  def __ne__(self, other):
12955 
    return not (self == other)
12956 
 
12957 
class markOrdersAsFirstDeliveryAttempted_result:
12958 
  """
12959 
  Attributes:
12960 
   - ex
12961 
  """
12962 
 
12963 
  thrift_spec = (
12964 
    None, # 0
12965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12966 
  )
12967 
 
12968 
  def __init__(self, ex=None,):
12969 
    self.ex = ex
12970 
 
12971 
  def read(self, iprot):
12972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12974 
      return
12975 
    iprot.readStructBegin()
12976 
    while True:
12977 
      (fname, ftype, fid) = iprot.readFieldBegin()
12978 
      if ftype == TType.STOP:
12979 
        break
12980 
      if fid == 1:
12981 
        if ftype == TType.STRUCT:
12982 
          self.ex = TransactionServiceException()
12983 
          self.ex.read(iprot)
12984 
        else:
12985 
          iprot.skip(ftype)
12986 
      else:
12987 
        iprot.skip(ftype)
12988 
      iprot.readFieldEnd()
12989 
    iprot.readStructEnd()
12990 
 
12991 
  def write(self, oprot):
12992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12994 
      return
12995 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
12996 
    if self.ex is not None:
12997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12998 
      self.ex.write(oprot)
12999 
      oprot.writeFieldEnd()
13000 
    oprot.writeFieldStop()
13001 
    oprot.writeStructEnd()
13002 
 
13003 
  def validate(self):
13004 
    return
13005 
 
13006 
 
13007 
  def __repr__(self):
13008 
    L = ['%s=%r' % (key, value)
13009 
      for key, value in self.__dict__.iteritems()]
13010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13011 
 
13012 
  def __eq__(self, other):
13013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13014 
 
13015 
  def __ne__(self, other):
13016 
    return not (self == other)
13017 
 
3064 chandransh 13018 
class getUndeliveredOrders_args:
1886 ankur.sing 13019 
  """
13020 
  Attributes:
3064 chandransh 13021 
   - providerId
13022 
   - warehouseId
1886 ankur.sing 13023 
  """
1627 ankur.sing 13024 
 
1886 ankur.sing 13025 
  thrift_spec = (
13026 
    None, # 0
3064 chandransh 13027 
    (1, TType.I64, 'providerId', None, None, ), # 1
13028 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13029 
  )
13030 
 
3064 chandransh 13031 
  def __init__(self, providerId=None, warehouseId=None,):
13032 
    self.providerId = providerId
13033 
    self.warehouseId = warehouseId
1886 ankur.sing 13034 
 
13035 
  def read(self, iprot):
13036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13038 
      return
13039 
    iprot.readStructBegin()
13040 
    while True:
13041 
      (fname, ftype, fid) = iprot.readFieldBegin()
13042 
      if ftype == TType.STOP:
13043 
        break
13044 
      if fid == 1:
13045 
        if ftype == TType.I64:
3064 chandransh 13046 
          self.providerId = iprot.readI64();
1886 ankur.sing 13047 
        else:
13048 
          iprot.skip(ftype)
3064 chandransh 13049 
      elif fid == 2:
13050 
        if ftype == TType.I64:
13051 
          self.warehouseId = iprot.readI64();
13052 
        else:
13053 
          iprot.skip(ftype)
1886 ankur.sing 13054 
      else:
13055 
        iprot.skip(ftype)
13056 
      iprot.readFieldEnd()
13057 
    iprot.readStructEnd()
13058 
 
13059 
  def write(self, oprot):
13060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13062 
      return
3064 chandransh 13063 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13064 
    if self.providerId is not None:
3064 chandransh 13065 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13066 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13067 
      oprot.writeFieldEnd()
3431 rajveer 13068 
    if self.warehouseId is not None:
3064 chandransh 13069 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13070 
      oprot.writeI64(self.warehouseId)
13071 
      oprot.writeFieldEnd()
1886 ankur.sing 13072 
    oprot.writeFieldStop()
13073 
    oprot.writeStructEnd()
13074 
 
3431 rajveer 13075 
  def validate(self):
13076 
    return
13077 
 
13078 
 
1886 ankur.sing 13079 
  def __repr__(self):
13080 
    L = ['%s=%r' % (key, value)
13081 
      for key, value in self.__dict__.iteritems()]
13082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13083 
 
13084 
  def __eq__(self, other):
13085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13086 
 
13087 
  def __ne__(self, other):
13088 
    return not (self == other)
13089 
 
3064 chandransh 13090 
class getUndeliveredOrders_result:
1886 ankur.sing 13091 
  """
13092 
  Attributes:
13093 
   - success
13094 
  """
13095 
 
13096 
  thrift_spec = (
13097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13098 
  )
13099 
 
13100 
  def __init__(self, success=None,):
13101 
    self.success = success
13102 
 
13103 
  def read(self, iprot):
13104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13106 
      return
13107 
    iprot.readStructBegin()
13108 
    while True:
13109 
      (fname, ftype, fid) = iprot.readFieldBegin()
13110 
      if ftype == TType.STOP:
13111 
        break
13112 
      if fid == 0:
13113 
        if ftype == TType.LIST:
13114 
          self.success = []
4910 phani.kuma 13115 
          (_etype276, _size273) = iprot.readListBegin()
13116 
          for _i277 in xrange(_size273):
13117 
            _elem278 = Order()
13118 
            _elem278.read(iprot)
13119 
            self.success.append(_elem278)
1886 ankur.sing 13120 
          iprot.readListEnd()
13121 
        else:
13122 
          iprot.skip(ftype)
13123 
      else:
13124 
        iprot.skip(ftype)
13125 
      iprot.readFieldEnd()
13126 
    iprot.readStructEnd()
13127 
 
13128 
  def write(self, oprot):
13129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13131 
      return
3064 chandransh 13132 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13133 
    if self.success is not None:
1886 ankur.sing 13134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 13136 
      for iter279 in self.success:
13137 
        iter279.write(oprot)
1886 ankur.sing 13138 
      oprot.writeListEnd()
13139 
      oprot.writeFieldEnd()
13140 
    oprot.writeFieldStop()
13141 
    oprot.writeStructEnd()
13142 
 
3431 rajveer 13143 
  def validate(self):
13144 
    return
13145 
 
13146 
 
1886 ankur.sing 13147 
  def __repr__(self):
13148 
    L = ['%s=%r' % (key, value)
13149 
      for key, value in self.__dict__.iteritems()]
13150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13151 
 
13152 
  def __eq__(self, other):
13153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13154 
 
13155 
  def __ne__(self, other):
13156 
    return not (self == other)
13157 
 
4783 phani.kuma 13158 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13159 
 
13160 
  thrift_spec = (
13161 
  )
13162 
 
13163 
  def read(self, iprot):
13164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13166 
      return
13167 
    iprot.readStructBegin()
13168 
    while True:
13169 
      (fname, ftype, fid) = iprot.readFieldBegin()
13170 
      if ftype == TType.STOP:
13171 
        break
13172 
      else:
13173 
        iprot.skip(ftype)
13174 
      iprot.readFieldEnd()
13175 
    iprot.readStructEnd()
13176 
 
13177 
  def write(self, oprot):
13178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13180 
      return
13181 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13182 
    oprot.writeFieldStop()
13183 
    oprot.writeStructEnd()
13184 
 
13185 
  def validate(self):
13186 
    return
13187 
 
13188 
 
13189 
  def __repr__(self):
13190 
    L = ['%s=%r' % (key, value)
13191 
      for key, value in self.__dict__.iteritems()]
13192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13193 
 
13194 
  def __eq__(self, other):
13195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13196 
 
13197 
  def __ne__(self, other):
13198 
    return not (self == other)
13199 
 
13200 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13201 
  """
13202 
  Attributes:
13203 
   - success
13204 
  """
13205 
 
13206 
  thrift_spec = (
13207 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13208 
  )
13209 
 
13210 
  def __init__(self, success=None,):
13211 
    self.success = success
13212 
 
13213 
  def read(self, iprot):
13214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13216 
      return
13217 
    iprot.readStructBegin()
13218 
    while True:
13219 
      (fname, ftype, fid) = iprot.readFieldBegin()
13220 
      if ftype == TType.STOP:
13221 
        break
13222 
      if fid == 0:
13223 
        if ftype == TType.LIST:
13224 
          self.success = []
4910 phani.kuma 13225 
          (_etype283, _size280) = iprot.readListBegin()
13226 
          for _i284 in xrange(_size280):
13227 
            _elem285 = Order()
13228 
            _elem285.read(iprot)
13229 
            self.success.append(_elem285)
4783 phani.kuma 13230 
          iprot.readListEnd()
13231 
        else:
13232 
          iprot.skip(ftype)
13233 
      else:
13234 
        iprot.skip(ftype)
13235 
      iprot.readFieldEnd()
13236 
    iprot.readStructEnd()
13237 
 
13238 
  def write(self, oprot):
13239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13241 
      return
13242 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13243 
    if self.success is not None:
13244 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13245 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 13246 
      for iter286 in self.success:
13247 
        iter286.write(oprot)
4783 phani.kuma 13248 
      oprot.writeListEnd()
13249 
      oprot.writeFieldEnd()
13250 
    oprot.writeFieldStop()
13251 
    oprot.writeStructEnd()
13252 
 
13253 
  def validate(self):
13254 
    return
13255 
 
13256 
 
13257 
  def __repr__(self):
13258 
    L = ['%s=%r' % (key, value)
13259 
      for key, value in self.__dict__.iteritems()]
13260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13261 
 
13262 
  def __eq__(self, other):
13263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13264 
 
13265 
  def __ne__(self, other):
13266 
    return not (self == other)
13267 
 
2536 chandransh 13268 
class toggleDOAFlag_args:
13269 
  """
13270 
  Attributes:
13271 
   - orderId
13272 
  """
1886 ankur.sing 13273 
 
2536 chandransh 13274 
  thrift_spec = (
13275 
    None, # 0
13276 
    (1, TType.I64, 'orderId', None, None, ), # 1
13277 
  )
13278 
 
13279 
  def __init__(self, orderId=None,):
13280 
    self.orderId = orderId
13281 
 
13282 
  def read(self, iprot):
13283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13285 
      return
13286 
    iprot.readStructBegin()
13287 
    while True:
13288 
      (fname, ftype, fid) = iprot.readFieldBegin()
13289 
      if ftype == TType.STOP:
13290 
        break
13291 
      if fid == 1:
13292 
        if ftype == TType.I64:
13293 
          self.orderId = iprot.readI64();
13294 
        else:
13295 
          iprot.skip(ftype)
13296 
      else:
13297 
        iprot.skip(ftype)
13298 
      iprot.readFieldEnd()
13299 
    iprot.readStructEnd()
13300 
 
13301 
  def write(self, oprot):
13302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13304 
      return
13305 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13306 
    if self.orderId is not None:
2536 chandransh 13307 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13308 
      oprot.writeI64(self.orderId)
13309 
      oprot.writeFieldEnd()
13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
3431 rajveer 13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
2536 chandransh 13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
13328 
class toggleDOAFlag_result:
13329 
  """
13330 
  Attributes:
13331 
   - success
13332 
   - ex
13333 
  """
13334 
 
13335 
  thrift_spec = (
13336 
    (0, TType.BOOL, 'success', None, None, ), # 0
13337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13338 
  )
13339 
 
13340 
  def __init__(self, success=None, ex=None,):
13341 
    self.success = success
13342 
    self.ex = ex
13343 
 
13344 
  def read(self, iprot):
13345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13347 
      return
13348 
    iprot.readStructBegin()
13349 
    while True:
13350 
      (fname, ftype, fid) = iprot.readFieldBegin()
13351 
      if ftype == TType.STOP:
13352 
        break
13353 
      if fid == 0:
13354 
        if ftype == TType.BOOL:
13355 
          self.success = iprot.readBool();
13356 
        else:
13357 
          iprot.skip(ftype)
13358 
      elif fid == 1:
13359 
        if ftype == TType.STRUCT:
13360 
          self.ex = TransactionServiceException()
13361 
          self.ex.read(iprot)
13362 
        else:
13363 
          iprot.skip(ftype)
13364 
      else:
13365 
        iprot.skip(ftype)
13366 
      iprot.readFieldEnd()
13367 
    iprot.readStructEnd()
13368 
 
13369 
  def write(self, oprot):
13370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13372 
      return
13373 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13374 
    if self.success is not None:
2536 chandransh 13375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13376 
      oprot.writeBool(self.success)
13377 
      oprot.writeFieldEnd()
3431 rajveer 13378 
    if self.ex is not None:
2536 chandransh 13379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13380 
      self.ex.write(oprot)
13381 
      oprot.writeFieldEnd()
13382 
    oprot.writeFieldStop()
13383 
    oprot.writeStructEnd()
13384 
 
3431 rajveer 13385 
  def validate(self):
13386 
    return
13387 
 
13388 
 
2536 chandransh 13389 
  def __repr__(self):
13390 
    L = ['%s=%r' % (key, value)
13391 
      for key, value in self.__dict__.iteritems()]
13392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13393 
 
13394 
  def __eq__(self, other):
13395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13396 
 
13397 
  def __ne__(self, other):
13398 
    return not (self == other)
13399 
 
4712 rajveer 13400 
class markOrderAsDelivered_args:
13401 
  """
13402 
  Attributes:
13403 
   - orderId
13404 
   - deliveryTimestamp
13405 
   - receiver
13406 
  """
13407 
 
13408 
  thrift_spec = None
13409 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13410 
    self.orderId = orderId
13411 
    self.deliveryTimestamp = deliveryTimestamp
13412 
    self.receiver = receiver
13413 
 
13414 
  def read(self, iprot):
13415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13417 
      return
13418 
    iprot.readStructBegin()
13419 
    while True:
13420 
      (fname, ftype, fid) = iprot.readFieldBegin()
13421 
      if ftype == TType.STOP:
13422 
        break
13423 
      if fid == 1:
13424 
        if ftype == TType.I64:
13425 
          self.orderId = iprot.readI64();
13426 
        else:
13427 
          iprot.skip(ftype)
13428 
      elif fid == 2:
13429 
        if ftype == TType.I64:
13430 
          self.deliveryTimestamp = iprot.readI64();
13431 
        else:
13432 
          iprot.skip(ftype)
13433 
      elif fid == -1:
13434 
        if ftype == TType.STRING:
13435 
          self.receiver = iprot.readString();
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      else:
13439 
        iprot.skip(ftype)
13440 
      iprot.readFieldEnd()
13441 
    iprot.readStructEnd()
13442 
 
13443 
  def write(self, oprot):
13444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13446 
      return
13447 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13448 
    if self.receiver is not None:
13449 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13450 
      oprot.writeString(self.receiver)
13451 
      oprot.writeFieldEnd()
13452 
    if self.orderId is not None:
13453 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13454 
      oprot.writeI64(self.orderId)
13455 
      oprot.writeFieldEnd()
13456 
    if self.deliveryTimestamp is not None:
13457 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13458 
      oprot.writeI64(self.deliveryTimestamp)
13459 
      oprot.writeFieldEnd()
13460 
    oprot.writeFieldStop()
13461 
    oprot.writeStructEnd()
13462 
 
13463 
  def validate(self):
13464 
    return
13465 
 
13466 
 
13467 
  def __repr__(self):
13468 
    L = ['%s=%r' % (key, value)
13469 
      for key, value in self.__dict__.iteritems()]
13470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13471 
 
13472 
  def __eq__(self, other):
13473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13474 
 
13475 
  def __ne__(self, other):
13476 
    return not (self == other)
13477 
 
13478 
class markOrderAsDelivered_result:
13479 
  """
13480 
  Attributes:
13481 
   - ex
13482 
  """
13483 
 
13484 
  thrift_spec = (
13485 
    None, # 0
13486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13487 
  )
13488 
 
13489 
  def __init__(self, ex=None,):
13490 
    self.ex = ex
13491 
 
13492 
  def read(self, iprot):
13493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13495 
      return
13496 
    iprot.readStructBegin()
13497 
    while True:
13498 
      (fname, ftype, fid) = iprot.readFieldBegin()
13499 
      if ftype == TType.STOP:
13500 
        break
13501 
      if fid == 1:
13502 
        if ftype == TType.STRUCT:
13503 
          self.ex = TransactionServiceException()
13504 
          self.ex.read(iprot)
13505 
        else:
13506 
          iprot.skip(ftype)
13507 
      else:
13508 
        iprot.skip(ftype)
13509 
      iprot.readFieldEnd()
13510 
    iprot.readStructEnd()
13511 
 
13512 
  def write(self, oprot):
13513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13515 
      return
13516 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13517 
    if self.ex is not None:
13518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13519 
      self.ex.write(oprot)
13520 
      oprot.writeFieldEnd()
13521 
    oprot.writeFieldStop()
13522 
    oprot.writeStructEnd()
13523 
 
13524 
  def validate(self):
13525 
    return
13526 
 
13527 
 
13528 
  def __repr__(self):
13529 
    L = ['%s=%r' % (key, value)
13530 
      for key, value in self.__dict__.iteritems()]
13531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13532 
 
13533 
  def __eq__(self, other):
13534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13535 
 
13536 
  def __ne__(self, other):
13537 
    return not (self == other)
13538 
 
4454 rajveer 13539 
class markOrderDoaRequestReceived_args:
13540 
  """
13541 
  Attributes:
13542 
   - orderId
13543 
  """
13544 
 
13545 
  thrift_spec = (
13546 
    None, # 0
13547 
    (1, TType.I64, 'orderId', None, None, ), # 1
13548 
  )
13549 
 
13550 
  def __init__(self, orderId=None,):
13551 
    self.orderId = orderId
13552 
 
13553 
  def read(self, iprot):
13554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13556 
      return
13557 
    iprot.readStructBegin()
13558 
    while True:
13559 
      (fname, ftype, fid) = iprot.readFieldBegin()
13560 
      if ftype == TType.STOP:
13561 
        break
13562 
      if fid == 1:
13563 
        if ftype == TType.I64:
13564 
          self.orderId = iprot.readI64();
13565 
        else:
13566 
          iprot.skip(ftype)
13567 
      else:
13568 
        iprot.skip(ftype)
13569 
      iprot.readFieldEnd()
13570 
    iprot.readStructEnd()
13571 
 
13572 
  def write(self, oprot):
13573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13575 
      return
13576 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13577 
    if self.orderId is not None:
13578 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13579 
      oprot.writeI64(self.orderId)
13580 
      oprot.writeFieldEnd()
13581 
    oprot.writeFieldStop()
13582 
    oprot.writeStructEnd()
13583 
 
13584 
  def validate(self):
13585 
    return
13586 
 
13587 
 
13588 
  def __repr__(self):
13589 
    L = ['%s=%r' % (key, value)
13590 
      for key, value in self.__dict__.iteritems()]
13591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13592 
 
13593 
  def __eq__(self, other):
13594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13595 
 
13596 
  def __ne__(self, other):
13597 
    return not (self == other)
13598 
 
13599 
class markOrderDoaRequestReceived_result:
13600 
  """
13601 
  Attributes:
13602 
   - success
13603 
   - ex
13604 
  """
13605 
 
13606 
  thrift_spec = (
13607 
    (0, TType.BOOL, 'success', None, None, ), # 0
13608 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13609 
  )
13610 
 
13611 
  def __init__(self, success=None, ex=None,):
13612 
    self.success = success
13613 
    self.ex = ex
13614 
 
13615 
  def read(self, iprot):
13616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13618 
      return
13619 
    iprot.readStructBegin()
13620 
    while True:
13621 
      (fname, ftype, fid) = iprot.readFieldBegin()
13622 
      if ftype == TType.STOP:
13623 
        break
13624 
      if fid == 0:
13625 
        if ftype == TType.BOOL:
13626 
          self.success = iprot.readBool();
13627 
        else:
13628 
          iprot.skip(ftype)
13629 
      elif fid == 1:
13630 
        if ftype == TType.STRUCT:
13631 
          self.ex = TransactionServiceException()
13632 
          self.ex.read(iprot)
13633 
        else:
13634 
          iprot.skip(ftype)
13635 
      else:
13636 
        iprot.skip(ftype)
13637 
      iprot.readFieldEnd()
13638 
    iprot.readStructEnd()
13639 
 
13640 
  def write(self, oprot):
13641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13643 
      return
13644 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13645 
    if self.success is not None:
13646 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13647 
      oprot.writeBool(self.success)
13648 
      oprot.writeFieldEnd()
13649 
    if self.ex is not None:
13650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13651 
      self.ex.write(oprot)
13652 
      oprot.writeFieldEnd()
13653 
    oprot.writeFieldStop()
13654 
    oprot.writeStructEnd()
13655 
 
13656 
  def validate(self):
13657 
    return
13658 
 
13659 
 
13660 
  def __repr__(self):
13661 
    L = ['%s=%r' % (key, value)
13662 
      for key, value in self.__dict__.iteritems()]
13663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13664 
 
13665 
  def __eq__(self, other):
13666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13667 
 
13668 
  def __ne__(self, other):
13669 
    return not (self == other)
13670 
 
13671 
class markOrderDoaRequestAuthorized_args:
13672 
  """
13673 
  Attributes:
13674 
   - orderId
13675 
   - isAuthorized
13676 
  """
13677 
 
13678 
  thrift_spec = (
13679 
    None, # 0
13680 
    (1, TType.I64, 'orderId', None, None, ), # 1
13681 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
13682 
  )
13683 
 
13684 
  def __init__(self, orderId=None, isAuthorized=None,):
13685 
    self.orderId = orderId
13686 
    self.isAuthorized = isAuthorized
13687 
 
13688 
  def read(self, iprot):
13689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13691 
      return
13692 
    iprot.readStructBegin()
13693 
    while True:
13694 
      (fname, ftype, fid) = iprot.readFieldBegin()
13695 
      if ftype == TType.STOP:
13696 
        break
13697 
      if fid == 1:
13698 
        if ftype == TType.I64:
13699 
          self.orderId = iprot.readI64();
13700 
        else:
13701 
          iprot.skip(ftype)
13702 
      elif fid == 2:
13703 
        if ftype == TType.BOOL:
13704 
          self.isAuthorized = iprot.readBool();
13705 
        else:
13706 
          iprot.skip(ftype)
13707 
      else:
13708 
        iprot.skip(ftype)
13709 
      iprot.readFieldEnd()
13710 
    iprot.readStructEnd()
13711 
 
13712 
  def write(self, oprot):
13713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13715 
      return
13716 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
13717 
    if self.orderId is not None:
13718 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13719 
      oprot.writeI64(self.orderId)
13720 
      oprot.writeFieldEnd()
13721 
    if self.isAuthorized is not None:
13722 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
13723 
      oprot.writeBool(self.isAuthorized)
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 markOrderDoaRequestAuthorized_result:
13744 
  """
13745 
  Attributes:
13746 
   - success
13747 
   - ex
13748 
  """
13749 
 
13750 
  thrift_spec = (
13751 
    (0, TType.BOOL, 'success', None, None, ), # 0
13752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13753 
  )
13754 
 
13755 
  def __init__(self, success=None, ex=None,):
13756 
    self.success = success
13757 
    self.ex = ex
13758 
 
13759 
  def read(self, iprot):
13760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13762 
      return
13763 
    iprot.readStructBegin()
13764 
    while True:
13765 
      (fname, ftype, fid) = iprot.readFieldBegin()
13766 
      if ftype == TType.STOP:
13767 
        break
13768 
      if fid == 0:
13769 
        if ftype == TType.BOOL:
13770 
          self.success = iprot.readBool();
13771 
        else:
13772 
          iprot.skip(ftype)
13773 
      elif fid == 1:
13774 
        if ftype == TType.STRUCT:
13775 
          self.ex = TransactionServiceException()
13776 
          self.ex.read(iprot)
13777 
        else:
13778 
          iprot.skip(ftype)
13779 
      else:
13780 
        iprot.skip(ftype)
13781 
      iprot.readFieldEnd()
13782 
    iprot.readStructEnd()
13783 
 
13784 
  def write(self, oprot):
13785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13787 
      return
13788 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
13789 
    if self.success is not None:
13790 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13791 
      oprot.writeBool(self.success)
13792 
      oprot.writeFieldEnd()
13793 
    if self.ex is not None:
13794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13795 
      self.ex.write(oprot)
13796 
      oprot.writeFieldEnd()
13797 
    oprot.writeFieldStop()
13798 
    oprot.writeStructEnd()
13799 
 
13800 
  def validate(self):
13801 
    return
13802 
 
13803 
 
13804 
  def __repr__(self):
13805 
    L = ['%s=%r' % (key, value)
13806 
      for key, value in self.__dict__.iteritems()]
13807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13808 
 
13809 
  def __eq__(self, other):
13810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13811 
 
13812 
  def __ne__(self, other):
13813 
    return not (self == other)
13814 
 
4488 rajveer 13815 
class markOrderReturnRequestReceived_args:
13816 
  """
13817 
  Attributes:
13818 
   - orderId
13819 
  """
13820 
 
13821 
  thrift_spec = (
13822 
    None, # 0
13823 
    (1, TType.I64, 'orderId', None, None, ), # 1
13824 
  )
13825 
 
13826 
  def __init__(self, orderId=None,):
13827 
    self.orderId = orderId
13828 
 
13829 
  def read(self, iprot):
13830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13832 
      return
13833 
    iprot.readStructBegin()
13834 
    while True:
13835 
      (fname, ftype, fid) = iprot.readFieldBegin()
13836 
      if ftype == TType.STOP:
13837 
        break
13838 
      if fid == 1:
13839 
        if ftype == TType.I64:
13840 
          self.orderId = iprot.readI64();
13841 
        else:
13842 
          iprot.skip(ftype)
13843 
      else:
13844 
        iprot.skip(ftype)
13845 
      iprot.readFieldEnd()
13846 
    iprot.readStructEnd()
13847 
 
13848 
  def write(self, oprot):
13849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13851 
      return
13852 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
13853 
    if self.orderId is not None:
13854 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13855 
      oprot.writeI64(self.orderId)
13856 
      oprot.writeFieldEnd()
13857 
    oprot.writeFieldStop()
13858 
    oprot.writeStructEnd()
13859 
 
13860 
  def validate(self):
13861 
    return
13862 
 
13863 
 
13864 
  def __repr__(self):
13865 
    L = ['%s=%r' % (key, value)
13866 
      for key, value in self.__dict__.iteritems()]
13867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13868 
 
13869 
  def __eq__(self, other):
13870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13871 
 
13872 
  def __ne__(self, other):
13873 
    return not (self == other)
13874 
 
13875 
class markOrderReturnRequestReceived_result:
13876 
  """
13877 
  Attributes:
13878 
   - success
13879 
   - ex
13880 
  """
13881 
 
13882 
  thrift_spec = (
13883 
    (0, TType.BOOL, 'success', None, None, ), # 0
13884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13885 
  )
13886 
 
13887 
  def __init__(self, success=None, ex=None,):
13888 
    self.success = success
13889 
    self.ex = ex
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 0:
13901 
        if ftype == TType.BOOL:
13902 
          self.success = iprot.readBool();
13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      elif fid == 1:
13906 
        if ftype == TType.STRUCT:
13907 
          self.ex = TransactionServiceException()
13908 
          self.ex.read(iprot)
13909 
        else:
13910 
          iprot.skip(ftype)
13911 
      else:
13912 
        iprot.skip(ftype)
13913 
      iprot.readFieldEnd()
13914 
    iprot.readStructEnd()
13915 
 
13916 
  def write(self, oprot):
13917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13919 
      return
13920 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
13921 
    if self.success is not None:
13922 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13923 
      oprot.writeBool(self.success)
13924 
      oprot.writeFieldEnd()
13925 
    if self.ex is not None:
13926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13927 
      self.ex.write(oprot)
13928 
      oprot.writeFieldEnd()
13929 
    oprot.writeFieldStop()
13930 
    oprot.writeStructEnd()
13931 
 
13932 
  def validate(self):
13933 
    return
13934 
 
13935 
 
13936 
  def __repr__(self):
13937 
    L = ['%s=%r' % (key, value)
13938 
      for key, value in self.__dict__.iteritems()]
13939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13940 
 
13941 
  def __eq__(self, other):
13942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13943 
 
13944 
  def __ne__(self, other):
13945 
    return not (self == other)
13946 
 
13947 
class markOrderReturnRequestAuthorized_args:
13948 
  """
13949 
  Attributes:
13950 
   - orderId
13951 
   - isAuthorized
13952 
  """
13953 
 
13954 
  thrift_spec = (
13955 
    None, # 0
13956 
    (1, TType.I64, 'orderId', None, None, ), # 1
13957 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
13958 
  )
13959 
 
13960 
  def __init__(self, orderId=None, isAuthorized=None,):
13961 
    self.orderId = orderId
13962 
    self.isAuthorized = isAuthorized
13963 
 
13964 
  def read(self, iprot):
13965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13967 
      return
13968 
    iprot.readStructBegin()
13969 
    while True:
13970 
      (fname, ftype, fid) = iprot.readFieldBegin()
13971 
      if ftype == TType.STOP:
13972 
        break
13973 
      if fid == 1:
13974 
        if ftype == TType.I64:
13975 
          self.orderId = iprot.readI64();
13976 
        else:
13977 
          iprot.skip(ftype)
13978 
      elif fid == 2:
13979 
        if ftype == TType.BOOL:
13980 
          self.isAuthorized = iprot.readBool();
13981 
        else:
13982 
          iprot.skip(ftype)
13983 
      else:
13984 
        iprot.skip(ftype)
13985 
      iprot.readFieldEnd()
13986 
    iprot.readStructEnd()
13987 
 
13988 
  def write(self, oprot):
13989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13991 
      return
13992 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
13993 
    if self.orderId is not None:
13994 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13995 
      oprot.writeI64(self.orderId)
13996 
      oprot.writeFieldEnd()
13997 
    if self.isAuthorized is not None:
13998 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
13999 
      oprot.writeBool(self.isAuthorized)
14000 
      oprot.writeFieldEnd()
14001 
    oprot.writeFieldStop()
14002 
    oprot.writeStructEnd()
14003 
 
14004 
  def validate(self):
14005 
    return
14006 
 
14007 
 
14008 
  def __repr__(self):
14009 
    L = ['%s=%r' % (key, value)
14010 
      for key, value in self.__dict__.iteritems()]
14011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14012 
 
14013 
  def __eq__(self, other):
14014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14015 
 
14016 
  def __ne__(self, other):
14017 
    return not (self == other)
14018 
 
14019 
class markOrderReturnRequestAuthorized_result:
14020 
  """
14021 
  Attributes:
14022 
   - success
14023 
   - ex
14024 
  """
14025 
 
14026 
  thrift_spec = (
14027 
    (0, TType.BOOL, 'success', None, None, ), # 0
14028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14029 
  )
14030 
 
14031 
  def __init__(self, success=None, ex=None,):
14032 
    self.success = success
14033 
    self.ex = ex
14034 
 
14035 
  def read(self, iprot):
14036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14038 
      return
14039 
    iprot.readStructBegin()
14040 
    while True:
14041 
      (fname, ftype, fid) = iprot.readFieldBegin()
14042 
      if ftype == TType.STOP:
14043 
        break
14044 
      if fid == 0:
14045 
        if ftype == TType.BOOL:
14046 
          self.success = iprot.readBool();
14047 
        else:
14048 
          iprot.skip(ftype)
14049 
      elif fid == 1:
14050 
        if ftype == TType.STRUCT:
14051 
          self.ex = TransactionServiceException()
14052 
          self.ex.read(iprot)
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      else:
14056 
        iprot.skip(ftype)
14057 
      iprot.readFieldEnd()
14058 
    iprot.readStructEnd()
14059 
 
14060 
  def write(self, oprot):
14061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14063 
      return
14064 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14065 
    if self.success is not None:
14066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14067 
      oprot.writeBool(self.success)
14068 
      oprot.writeFieldEnd()
14069 
    if self.ex is not None:
14070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14071 
      self.ex.write(oprot)
14072 
      oprot.writeFieldEnd()
14073 
    oprot.writeFieldStop()
14074 
    oprot.writeStructEnd()
14075 
 
14076 
  def validate(self):
14077 
    return
14078 
 
14079 
 
14080 
  def __repr__(self):
14081 
    L = ['%s=%r' % (key, value)
14082 
      for key, value in self.__dict__.iteritems()]
14083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14084 
 
14085 
  def __eq__(self, other):
14086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14087 
 
14088 
  def __ne__(self, other):
14089 
    return not (self == other)
14090 
 
2536 chandransh 14091 
class requestPickupNumber_args:
14092 
  """
14093 
  Attributes:
14094 
   - orderId
4579 rajveer 14095 
   - providerId
2536 chandransh 14096 
  """
14097 
 
14098 
  thrift_spec = (
14099 
    None, # 0
14100 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14101 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14102 
  )
14103 
 
4579 rajveer 14104 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14105 
    self.orderId = orderId
4579 rajveer 14106 
    self.providerId = providerId
2536 chandransh 14107 
 
14108 
  def read(self, iprot):
14109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14111 
      return
14112 
    iprot.readStructBegin()
14113 
    while True:
14114 
      (fname, ftype, fid) = iprot.readFieldBegin()
14115 
      if ftype == TType.STOP:
14116 
        break
14117 
      if fid == 1:
14118 
        if ftype == TType.I64:
14119 
          self.orderId = iprot.readI64();
14120 
        else:
14121 
          iprot.skip(ftype)
4579 rajveer 14122 
      elif fid == 2:
14123 
        if ftype == TType.I64:
14124 
          self.providerId = iprot.readI64();
14125 
        else:
14126 
          iprot.skip(ftype)
2536 chandransh 14127 
      else:
14128 
        iprot.skip(ftype)
14129 
      iprot.readFieldEnd()
14130 
    iprot.readStructEnd()
14131 
 
14132 
  def write(self, oprot):
14133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14135 
      return
14136 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14137 
    if self.orderId is not None:
2536 chandransh 14138 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14139 
      oprot.writeI64(self.orderId)
14140 
      oprot.writeFieldEnd()
4579 rajveer 14141 
    if self.providerId is not None:
14142 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14143 
      oprot.writeI64(self.providerId)
14144 
      oprot.writeFieldEnd()
2536 chandransh 14145 
    oprot.writeFieldStop()
14146 
    oprot.writeStructEnd()
14147 
 
3431 rajveer 14148 
  def validate(self):
14149 
    return
14150 
 
14151 
 
2536 chandransh 14152 
  def __repr__(self):
14153 
    L = ['%s=%r' % (key, value)
14154 
      for key, value in self.__dict__.iteritems()]
14155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14156 
 
14157 
  def __eq__(self, other):
14158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14159 
 
14160 
  def __ne__(self, other):
14161 
    return not (self == other)
14162 
 
14163 
class requestPickupNumber_result:
14164 
  """
14165 
  Attributes:
14166 
   - success
14167 
   - ex
14168 
  """
14169 
 
14170 
  thrift_spec = (
14171 
    (0, TType.BOOL, 'success', None, None, ), # 0
14172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14173 
  )
14174 
 
14175 
  def __init__(self, success=None, ex=None,):
14176 
    self.success = success
14177 
    self.ex = ex
14178 
 
14179 
  def read(self, iprot):
14180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14182 
      return
14183 
    iprot.readStructBegin()
14184 
    while True:
14185 
      (fname, ftype, fid) = iprot.readFieldBegin()
14186 
      if ftype == TType.STOP:
14187 
        break
14188 
      if fid == 0:
14189 
        if ftype == TType.BOOL:
14190 
          self.success = iprot.readBool();
14191 
        else:
14192 
          iprot.skip(ftype)
14193 
      elif fid == 1:
14194 
        if ftype == TType.STRUCT:
14195 
          self.ex = TransactionServiceException()
14196 
          self.ex.read(iprot)
14197 
        else:
14198 
          iprot.skip(ftype)
14199 
      else:
14200 
        iprot.skip(ftype)
14201 
      iprot.readFieldEnd()
14202 
    iprot.readStructEnd()
14203 
 
14204 
  def write(self, oprot):
14205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14207 
      return
14208 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14209 
    if self.success is not None:
2536 chandransh 14210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14211 
      oprot.writeBool(self.success)
14212 
      oprot.writeFieldEnd()
3431 rajveer 14213 
    if self.ex is not None:
2536 chandransh 14214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14215 
      self.ex.write(oprot)
14216 
      oprot.writeFieldEnd()
14217 
    oprot.writeFieldStop()
14218 
    oprot.writeStructEnd()
14219 
 
3431 rajveer 14220 
  def validate(self):
14221 
    return
14222 
 
14223 
 
2536 chandransh 14224 
  def __repr__(self):
14225 
    L = ['%s=%r' % (key, value)
14226 
      for key, value in self.__dict__.iteritems()]
14227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14228 
 
14229 
  def __eq__(self, other):
14230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14231 
 
14232 
  def __ne__(self, other):
14233 
    return not (self == other)
14234 
 
14235 
class authorizePickup_args:
14236 
  """
14237 
  Attributes:
14238 
   - orderId
14239 
   - pickupNumber
4602 rajveer 14240 
   - providerId
2536 chandransh 14241 
  """
14242 
 
14243 
  thrift_spec = (
14244 
    None, # 0
14245 
    (1, TType.I64, 'orderId', None, None, ), # 1
14246 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14247 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14248 
  )
14249 
 
4602 rajveer 14250 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14251 
    self.orderId = orderId
14252 
    self.pickupNumber = pickupNumber
4602 rajveer 14253 
    self.providerId = providerId
2536 chandransh 14254 
 
14255 
  def read(self, iprot):
14256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14258 
      return
14259 
    iprot.readStructBegin()
14260 
    while True:
14261 
      (fname, ftype, fid) = iprot.readFieldBegin()
14262 
      if ftype == TType.STOP:
14263 
        break
14264 
      if fid == 1:
14265 
        if ftype == TType.I64:
14266 
          self.orderId = iprot.readI64();
14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      elif fid == 2:
14270 
        if ftype == TType.STRING:
14271 
          self.pickupNumber = iprot.readString();
14272 
        else:
14273 
          iprot.skip(ftype)
4602 rajveer 14274 
      elif fid == 3:
14275 
        if ftype == TType.I64:
14276 
          self.providerId = iprot.readI64();
14277 
        else:
14278 
          iprot.skip(ftype)
2536 chandransh 14279 
      else:
14280 
        iprot.skip(ftype)
14281 
      iprot.readFieldEnd()
14282 
    iprot.readStructEnd()
14283 
 
14284 
  def write(self, oprot):
14285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14287 
      return
14288 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14289 
    if self.orderId is not None:
2536 chandransh 14290 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14291 
      oprot.writeI64(self.orderId)
14292 
      oprot.writeFieldEnd()
3431 rajveer 14293 
    if self.pickupNumber is not None:
2536 chandransh 14294 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14295 
      oprot.writeString(self.pickupNumber)
14296 
      oprot.writeFieldEnd()
4602 rajveer 14297 
    if self.providerId is not None:
14298 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14299 
      oprot.writeI64(self.providerId)
14300 
      oprot.writeFieldEnd()
2536 chandransh 14301 
    oprot.writeFieldStop()
14302 
    oprot.writeStructEnd()
14303 
 
3431 rajveer 14304 
  def validate(self):
14305 
    return
14306 
 
14307 
 
2536 chandransh 14308 
  def __repr__(self):
14309 
    L = ['%s=%r' % (key, value)
14310 
      for key, value in self.__dict__.iteritems()]
14311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14312 
 
14313 
  def __eq__(self, other):
14314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14315 
 
14316 
  def __ne__(self, other):
14317 
    return not (self == other)
14318 
 
14319 
class authorizePickup_result:
14320 
  """
14321 
  Attributes:
14322 
   - success
14323 
   - ex
14324 
  """
14325 
 
14326 
  thrift_spec = (
14327 
    (0, TType.BOOL, 'success', None, None, ), # 0
14328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14329 
  )
14330 
 
14331 
  def __init__(self, success=None, ex=None,):
14332 
    self.success = success
14333 
    self.ex = ex
14334 
 
14335 
  def read(self, iprot):
14336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14338 
      return
14339 
    iprot.readStructBegin()
14340 
    while True:
14341 
      (fname, ftype, fid) = iprot.readFieldBegin()
14342 
      if ftype == TType.STOP:
14343 
        break
14344 
      if fid == 0:
14345 
        if ftype == TType.BOOL:
14346 
          self.success = iprot.readBool();
14347 
        else:
14348 
          iprot.skip(ftype)
14349 
      elif fid == 1:
14350 
        if ftype == TType.STRUCT:
14351 
          self.ex = TransactionServiceException()
14352 
          self.ex.read(iprot)
14353 
        else:
14354 
          iprot.skip(ftype)
14355 
      else:
14356 
        iprot.skip(ftype)
14357 
      iprot.readFieldEnd()
14358 
    iprot.readStructEnd()
14359 
 
14360 
  def write(self, oprot):
14361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14363 
      return
14364 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14365 
    if self.success is not None:
2536 chandransh 14366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14367 
      oprot.writeBool(self.success)
14368 
      oprot.writeFieldEnd()
3431 rajveer 14369 
    if self.ex is not None:
2536 chandransh 14370 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14371 
      self.ex.write(oprot)
14372 
      oprot.writeFieldEnd()
14373 
    oprot.writeFieldStop()
14374 
    oprot.writeStructEnd()
14375 
 
3431 rajveer 14376 
  def validate(self):
14377 
    return
14378 
 
14379 
 
2536 chandransh 14380 
  def __repr__(self):
14381 
    L = ['%s=%r' % (key, value)
14382 
      for key, value in self.__dict__.iteritems()]
14383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14384 
 
14385 
  def __eq__(self, other):
14386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14387 
 
14388 
  def __ne__(self, other):
14389 
    return not (self == other)
14390 
 
2764 chandransh 14391 
class markDoasAsPickedUp_args:
14392 
  """
14393 
  Attributes:
14394 
   - providerId
14395 
   - pickupDetails
14396 
  """
14397 
 
14398 
  thrift_spec = (
14399 
    None, # 0
14400 
    (1, TType.I64, 'providerId', None, None, ), # 1
14401 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14402 
  )
14403 
 
14404 
  def __init__(self, providerId=None, pickupDetails=None,):
14405 
    self.providerId = providerId
14406 
    self.pickupDetails = pickupDetails
14407 
 
14408 
  def read(self, iprot):
14409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14411 
      return
14412 
    iprot.readStructBegin()
14413 
    while True:
14414 
      (fname, ftype, fid) = iprot.readFieldBegin()
14415 
      if ftype == TType.STOP:
14416 
        break
14417 
      if fid == 1:
14418 
        if ftype == TType.I64:
14419 
          self.providerId = iprot.readI64();
14420 
        else:
14421 
          iprot.skip(ftype)
14422 
      elif fid == 2:
14423 
        if ftype == TType.MAP:
14424 
          self.pickupDetails = {}
4910 phani.kuma 14425 
          (_ktype288, _vtype289, _size287 ) = iprot.readMapBegin()
14426 
          for _i291 in xrange(_size287):
14427 
            _key292 = iprot.readString();
14428 
            _val293 = iprot.readString();
14429 
            self.pickupDetails[_key292] = _val293
2764 chandransh 14430 
          iprot.readMapEnd()
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('markDoasAsPickedUp_args')
3431 rajveer 14443 
    if self.providerId is not None:
2764 chandransh 14444 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14445 
      oprot.writeI64(self.providerId)
14446 
      oprot.writeFieldEnd()
3431 rajveer 14447 
    if self.pickupDetails is not None:
2764 chandransh 14448 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14449 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4910 phani.kuma 14450 
      for kiter294,viter295 in self.pickupDetails.items():
14451 
        oprot.writeString(kiter294)
14452 
        oprot.writeString(viter295)
2764 chandransh 14453 
      oprot.writeMapEnd()
14454 
      oprot.writeFieldEnd()
14455 
    oprot.writeFieldStop()
14456 
    oprot.writeStructEnd()
14457 
 
3431 rajveer 14458 
  def validate(self):
14459 
    return
14460 
 
14461 
 
2764 chandransh 14462 
  def __repr__(self):
14463 
    L = ['%s=%r' % (key, value)
14464 
      for key, value in self.__dict__.iteritems()]
14465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14466 
 
14467 
  def __eq__(self, other):
14468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14469 
 
14470 
  def __ne__(self, other):
14471 
    return not (self == other)
14472 
 
14473 
class markDoasAsPickedUp_result:
4910 phani.kuma 14474 
 
14475 
  thrift_spec = (
14476 
  )
14477 
 
14478 
  def read(self, iprot):
14479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14481 
      return
14482 
    iprot.readStructBegin()
14483 
    while True:
14484 
      (fname, ftype, fid) = iprot.readFieldBegin()
14485 
      if ftype == TType.STOP:
14486 
        break
14487 
      else:
14488 
        iprot.skip(ftype)
14489 
      iprot.readFieldEnd()
14490 
    iprot.readStructEnd()
14491 
 
14492 
  def write(self, oprot):
14493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14495 
      return
14496 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14497 
    oprot.writeFieldStop()
14498 
    oprot.writeStructEnd()
14499 
 
14500 
  def validate(self):
14501 
    return
14502 
 
14503 
 
14504 
  def __repr__(self):
14505 
    L = ['%s=%r' % (key, value)
14506 
      for key, value in self.__dict__.iteritems()]
14507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14508 
 
14509 
  def __eq__(self, other):
14510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14511 
 
14512 
  def __ne__(self, other):
14513 
    return not (self == other)
14514 
 
14515 
class getDoasNotPickedUp_args:
2764 chandransh 14516 
  """
14517 
  Attributes:
4910 phani.kuma 14518 
   - providerId
14519 
  """
14520 
 
14521 
  thrift_spec = (
14522 
    None, # 0
14523 
    (1, TType.I64, 'providerId', None, None, ), # 1
14524 
  )
14525 
 
14526 
  def __init__(self, providerId=None,):
14527 
    self.providerId = providerId
14528 
 
14529 
  def read(self, iprot):
14530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14532 
      return
14533 
    iprot.readStructBegin()
14534 
    while True:
14535 
      (fname, ftype, fid) = iprot.readFieldBegin()
14536 
      if ftype == TType.STOP:
14537 
        break
14538 
      if fid == 1:
14539 
        if ftype == TType.I64:
14540 
          self.providerId = iprot.readI64();
14541 
        else:
14542 
          iprot.skip(ftype)
14543 
      else:
14544 
        iprot.skip(ftype)
14545 
      iprot.readFieldEnd()
14546 
    iprot.readStructEnd()
14547 
 
14548 
  def write(self, oprot):
14549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14551 
      return
14552 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14553 
    if self.providerId is not None:
14554 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14555 
      oprot.writeI64(self.providerId)
14556 
      oprot.writeFieldEnd()
14557 
    oprot.writeFieldStop()
14558 
    oprot.writeStructEnd()
14559 
 
14560 
  def validate(self):
14561 
    return
14562 
 
14563 
 
14564 
  def __repr__(self):
14565 
    L = ['%s=%r' % (key, value)
14566 
      for key, value in self.__dict__.iteritems()]
14567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14568 
 
14569 
  def __eq__(self, other):
14570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14571 
 
14572 
  def __ne__(self, other):
14573 
    return not (self == other)
14574 
 
14575 
class getDoasNotPickedUp_result:
14576 
  """
14577 
  Attributes:
2764 chandransh 14578 
   - success
14579 
  """
14580 
 
14581 
  thrift_spec = (
14582 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14583 
  )
14584 
 
14585 
  def __init__(self, success=None,):
14586 
    self.success = success
14587 
 
14588 
  def read(self, iprot):
14589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14591 
      return
14592 
    iprot.readStructBegin()
14593 
    while True:
14594 
      (fname, ftype, fid) = iprot.readFieldBegin()
14595 
      if ftype == TType.STOP:
14596 
        break
14597 
      if fid == 0:
14598 
        if ftype == TType.LIST:
14599 
          self.success = []
4910 phani.kuma 14600 
          (_etype299, _size296) = iprot.readListBegin()
14601 
          for _i300 in xrange(_size296):
14602 
            _elem301 = Order()
14603 
            _elem301.read(iprot)
14604 
            self.success.append(_elem301)
2764 chandransh 14605 
          iprot.readListEnd()
14606 
        else:
14607 
          iprot.skip(ftype)
14608 
      else:
14609 
        iprot.skip(ftype)
14610 
      iprot.readFieldEnd()
14611 
    iprot.readStructEnd()
14612 
 
14613 
  def write(self, oprot):
14614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14616 
      return
4910 phani.kuma 14617 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14618 
    if self.success is not None:
2764 chandransh 14619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 14621 
      for iter302 in self.success:
14622 
        iter302.write(oprot)
2764 chandransh 14623 
      oprot.writeListEnd()
14624 
      oprot.writeFieldEnd()
14625 
    oprot.writeFieldStop()
14626 
    oprot.writeStructEnd()
14627 
 
3431 rajveer 14628 
  def validate(self):
14629 
    return
14630 
 
14631 
 
2764 chandransh 14632 
  def __repr__(self):
14633 
    L = ['%s=%r' % (key, value)
14634 
      for key, value in self.__dict__.iteritems()]
14635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14636 
 
14637 
  def __eq__(self, other):
14638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14639 
 
14640 
  def __ne__(self, other):
14641 
    return not (self == other)
14642 
 
4741 phani.kuma 14643 
class markReturnOrdersAsPickedUp_args:
14644 
  """
14645 
  Attributes:
14646 
   - providerId
14647 
   - pickupDetails
14648 
  """
14649 
 
14650 
  thrift_spec = (
14651 
    None, # 0
14652 
    (1, TType.I64, 'providerId', None, None, ), # 1
14653 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14654 
  )
14655 
 
14656 
  def __init__(self, providerId=None, pickupDetails=None,):
14657 
    self.providerId = providerId
14658 
    self.pickupDetails = pickupDetails
14659 
 
14660 
  def read(self, iprot):
14661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14663 
      return
14664 
    iprot.readStructBegin()
14665 
    while True:
14666 
      (fname, ftype, fid) = iprot.readFieldBegin()
14667 
      if ftype == TType.STOP:
14668 
        break
14669 
      if fid == 1:
14670 
        if ftype == TType.I64:
14671 
          self.providerId = iprot.readI64();
14672 
        else:
14673 
          iprot.skip(ftype)
14674 
      elif fid == 2:
14675 
        if ftype == TType.MAP:
14676 
          self.pickupDetails = {}
4910 phani.kuma 14677 
          (_ktype304, _vtype305, _size303 ) = iprot.readMapBegin()
14678 
          for _i307 in xrange(_size303):
14679 
            _key308 = iprot.readString();
14680 
            _val309 = iprot.readString();
14681 
            self.pickupDetails[_key308] = _val309
4741 phani.kuma 14682 
          iprot.readMapEnd()
14683 
        else:
14684 
          iprot.skip(ftype)
14685 
      else:
14686 
        iprot.skip(ftype)
14687 
      iprot.readFieldEnd()
14688 
    iprot.readStructEnd()
14689 
 
14690 
  def write(self, oprot):
14691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14693 
      return
14694 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
14695 
    if self.providerId is not None:
14696 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14697 
      oprot.writeI64(self.providerId)
14698 
      oprot.writeFieldEnd()
14699 
    if self.pickupDetails is not None:
14700 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14701 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4910 phani.kuma 14702 
      for kiter310,viter311 in self.pickupDetails.items():
14703 
        oprot.writeString(kiter310)
14704 
        oprot.writeString(viter311)
4741 phani.kuma 14705 
      oprot.writeMapEnd()
14706 
      oprot.writeFieldEnd()
14707 
    oprot.writeFieldStop()
14708 
    oprot.writeStructEnd()
14709 
 
14710 
  def validate(self):
14711 
    return
14712 
 
14713 
 
14714 
  def __repr__(self):
14715 
    L = ['%s=%r' % (key, value)
14716 
      for key, value in self.__dict__.iteritems()]
14717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14718 
 
14719 
  def __eq__(self, other):
14720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14721 
 
14722 
  def __ne__(self, other):
14723 
    return not (self == other)
14724 
 
14725 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 14726 
 
14727 
  thrift_spec = (
14728 
  )
14729 
 
14730 
  def read(self, iprot):
14731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14733 
      return
14734 
    iprot.readStructBegin()
14735 
    while True:
14736 
      (fname, ftype, fid) = iprot.readFieldBegin()
14737 
      if ftype == TType.STOP:
14738 
        break
14739 
      else:
14740 
        iprot.skip(ftype)
14741 
      iprot.readFieldEnd()
14742 
    iprot.readStructEnd()
14743 
 
14744 
  def write(self, oprot):
14745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14747 
      return
14748 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
14749 
    oprot.writeFieldStop()
14750 
    oprot.writeStructEnd()
14751 
 
14752 
  def validate(self):
14753 
    return
14754 
 
14755 
 
14756 
  def __repr__(self):
14757 
    L = ['%s=%r' % (key, value)
14758 
      for key, value in self.__dict__.iteritems()]
14759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14760 
 
14761 
  def __eq__(self, other):
14762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14763 
 
14764 
  def __ne__(self, other):
14765 
    return not (self == other)
14766 
 
14767 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 14768 
  """
14769 
  Attributes:
4910 phani.kuma 14770 
   - providerId
14771 
  """
14772 
 
14773 
  thrift_spec = (
14774 
    None, # 0
14775 
    (1, TType.I64, 'providerId', None, None, ), # 1
14776 
  )
14777 
 
14778 
  def __init__(self, providerId=None,):
14779 
    self.providerId = providerId
14780 
 
14781 
  def read(self, iprot):
14782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14784 
      return
14785 
    iprot.readStructBegin()
14786 
    while True:
14787 
      (fname, ftype, fid) = iprot.readFieldBegin()
14788 
      if ftype == TType.STOP:
14789 
        break
14790 
      if fid == 1:
14791 
        if ftype == TType.I64:
14792 
          self.providerId = iprot.readI64();
14793 
        else:
14794 
          iprot.skip(ftype)
14795 
      else:
14796 
        iprot.skip(ftype)
14797 
      iprot.readFieldEnd()
14798 
    iprot.readStructEnd()
14799 
 
14800 
  def write(self, oprot):
14801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14803 
      return
14804 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
14805 
    if self.providerId is not None:
14806 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14807 
      oprot.writeI64(self.providerId)
14808 
      oprot.writeFieldEnd()
14809 
    oprot.writeFieldStop()
14810 
    oprot.writeStructEnd()
14811 
 
14812 
  def validate(self):
14813 
    return
14814 
 
14815 
 
14816 
  def __repr__(self):
14817 
    L = ['%s=%r' % (key, value)
14818 
      for key, value in self.__dict__.iteritems()]
14819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14820 
 
14821 
  def __eq__(self, other):
14822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14823 
 
14824 
  def __ne__(self, other):
14825 
    return not (self == other)
14826 
 
14827 
class getReturnOrdersNotPickedUp_result:
14828 
  """
14829 
  Attributes:
4741 phani.kuma 14830 
   - success
14831 
  """
14832 
 
14833 
  thrift_spec = (
14834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14835 
  )
14836 
 
14837 
  def __init__(self, success=None,):
14838 
    self.success = success
14839 
 
14840 
  def read(self, iprot):
14841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14843 
      return
14844 
    iprot.readStructBegin()
14845 
    while True:
14846 
      (fname, ftype, fid) = iprot.readFieldBegin()
14847 
      if ftype == TType.STOP:
14848 
        break
14849 
      if fid == 0:
14850 
        if ftype == TType.LIST:
14851 
          self.success = []
4910 phani.kuma 14852 
          (_etype315, _size312) = iprot.readListBegin()
14853 
          for _i316 in xrange(_size312):
14854 
            _elem317 = Order()
14855 
            _elem317.read(iprot)
14856 
            self.success.append(_elem317)
4741 phani.kuma 14857 
          iprot.readListEnd()
14858 
        else:
14859 
          iprot.skip(ftype)
14860 
      else:
14861 
        iprot.skip(ftype)
14862 
      iprot.readFieldEnd()
14863 
    iprot.readStructEnd()
14864 
 
14865 
  def write(self, oprot):
14866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14868 
      return
4910 phani.kuma 14869 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 14870 
    if self.success is not None:
14871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 14873 
      for iter318 in self.success:
14874 
        iter318.write(oprot)
4741 phani.kuma 14875 
      oprot.writeListEnd()
14876 
      oprot.writeFieldEnd()
14877 
    oprot.writeFieldStop()
14878 
    oprot.writeStructEnd()
14879 
 
14880 
  def validate(self):
14881 
    return
14882 
 
14883 
 
14884 
  def __repr__(self):
14885 
    L = ['%s=%r' % (key, value)
14886 
      for key, value in self.__dict__.iteritems()]
14887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14888 
 
14889 
  def __eq__(self, other):
14890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14891 
 
14892 
  def __ne__(self, other):
14893 
    return not (self == other)
14894 
 
2616 chandransh 14895 
class receiveReturn_args:
2591 chandransh 14896 
  """
14897 
  Attributes:
14898 
   - orderId
4479 rajveer 14899 
   - receiveCondition
2591 chandransh 14900 
  """
2536 chandransh 14901 
 
2591 chandransh 14902 
  thrift_spec = (
14903 
    None, # 0
14904 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 14905 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 14906 
  )
14907 
 
4479 rajveer 14908 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 14909 
    self.orderId = orderId
4479 rajveer 14910 
    self.receiveCondition = receiveCondition
2591 chandransh 14911 
 
14912 
  def read(self, iprot):
14913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14915 
      return
14916 
    iprot.readStructBegin()
14917 
    while True:
14918 
      (fname, ftype, fid) = iprot.readFieldBegin()
14919 
      if ftype == TType.STOP:
14920 
        break
14921 
      if fid == 1:
14922 
        if ftype == TType.I64:
14923 
          self.orderId = iprot.readI64();
14924 
        else:
14925 
          iprot.skip(ftype)
4479 rajveer 14926 
      elif fid == 2:
14927 
        if ftype == TType.I64:
14928 
          self.receiveCondition = iprot.readI64();
14929 
        else:
14930 
          iprot.skip(ftype)
2591 chandransh 14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
2616 chandransh 14940 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 14941 
    if self.orderId is not None:
2591 chandransh 14942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14943 
      oprot.writeI64(self.orderId)
14944 
      oprot.writeFieldEnd()
4479 rajveer 14945 
    if self.receiveCondition is not None:
14946 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
14947 
      oprot.writeI64(self.receiveCondition)
14948 
      oprot.writeFieldEnd()
2591 chandransh 14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
3431 rajveer 14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
2591 chandransh 14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
14966 
 
2616 chandransh 14967 
class receiveReturn_result:
2591 chandransh 14968 
  """
14969 
  Attributes:
14970 
   - success
14971 
   - ex
14972 
  """
14973 
 
14974 
  thrift_spec = (
14975 
    (0, TType.BOOL, 'success', None, None, ), # 0
14976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14977 
  )
14978 
 
14979 
  def __init__(self, success=None, ex=None,):
14980 
    self.success = success
14981 
    self.ex = ex
14982 
 
14983 
  def read(self, iprot):
14984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14986 
      return
14987 
    iprot.readStructBegin()
14988 
    while True:
14989 
      (fname, ftype, fid) = iprot.readFieldBegin()
14990 
      if ftype == TType.STOP:
14991 
        break
14992 
      if fid == 0:
14993 
        if ftype == TType.BOOL:
14994 
          self.success = iprot.readBool();
14995 
        else:
14996 
          iprot.skip(ftype)
14997 
      elif fid == 1:
14998 
        if ftype == TType.STRUCT:
14999 
          self.ex = TransactionServiceException()
15000 
          self.ex.read(iprot)
15001 
        else:
15002 
          iprot.skip(ftype)
15003 
      else:
15004 
        iprot.skip(ftype)
15005 
      iprot.readFieldEnd()
15006 
    iprot.readStructEnd()
15007 
 
15008 
  def write(self, oprot):
15009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15011 
      return
2616 chandransh 15012 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15013 
    if self.success is not None:
2591 chandransh 15014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15015 
      oprot.writeBool(self.success)
15016 
      oprot.writeFieldEnd()
3431 rajveer 15017 
    if self.ex is not None:
2591 chandransh 15018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15019 
      self.ex.write(oprot)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
3431 rajveer 15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
2591 chandransh 15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
15038 
 
15039 
class validateDoa_args:
15040 
  """
15041 
  Attributes:
15042 
   - orderId
15043 
   - isValid
15044 
  """
15045 
 
15046 
  thrift_spec = (
15047 
    None, # 0
15048 
    (1, TType.I64, 'orderId', None, None, ), # 1
15049 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15050 
  )
15051 
 
15052 
  def __init__(self, orderId=None, isValid=None,):
15053 
    self.orderId = orderId
15054 
    self.isValid = isValid
15055 
 
15056 
  def read(self, iprot):
15057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15059 
      return
15060 
    iprot.readStructBegin()
15061 
    while True:
15062 
      (fname, ftype, fid) = iprot.readFieldBegin()
15063 
      if ftype == TType.STOP:
15064 
        break
15065 
      if fid == 1:
15066 
        if ftype == TType.I64:
15067 
          self.orderId = iprot.readI64();
15068 
        else:
15069 
          iprot.skip(ftype)
15070 
      elif fid == 2:
15071 
        if ftype == TType.BOOL:
15072 
          self.isValid = iprot.readBool();
15073 
        else:
15074 
          iprot.skip(ftype)
15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
15084 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15085 
    if self.orderId is not None:
2591 chandransh 15086 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15087 
      oprot.writeI64(self.orderId)
15088 
      oprot.writeFieldEnd()
3431 rajveer 15089 
    if self.isValid is not None:
2591 chandransh 15090 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15091 
      oprot.writeBool(self.isValid)
15092 
      oprot.writeFieldEnd()
15093 
    oprot.writeFieldStop()
15094 
    oprot.writeStructEnd()
15095 
 
3431 rajveer 15096 
  def validate(self):
15097 
    return
15098 
 
15099 
 
2591 chandransh 15100 
  def __repr__(self):
15101 
    L = ['%s=%r' % (key, value)
15102 
      for key, value in self.__dict__.iteritems()]
15103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15104 
 
15105 
  def __eq__(self, other):
15106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15107 
 
15108 
  def __ne__(self, other):
15109 
    return not (self == other)
15110 
 
15111 
class validateDoa_result:
15112 
  """
15113 
  Attributes:
15114 
   - success
15115 
   - ex
15116 
  """
15117 
 
15118 
  thrift_spec = (
15119 
    (0, TType.BOOL, 'success', None, None, ), # 0
15120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15121 
  )
15122 
 
15123 
  def __init__(self, success=None, ex=None,):
15124 
    self.success = success
15125 
    self.ex = ex
15126 
 
15127 
  def read(self, iprot):
15128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15130 
      return
15131 
    iprot.readStructBegin()
15132 
    while True:
15133 
      (fname, ftype, fid) = iprot.readFieldBegin()
15134 
      if ftype == TType.STOP:
15135 
        break
15136 
      if fid == 0:
15137 
        if ftype == TType.BOOL:
15138 
          self.success = iprot.readBool();
15139 
        else:
15140 
          iprot.skip(ftype)
15141 
      elif fid == 1:
15142 
        if ftype == TType.STRUCT:
15143 
          self.ex = TransactionServiceException()
15144 
          self.ex.read(iprot)
15145 
        else:
15146 
          iprot.skip(ftype)
15147 
      else:
15148 
        iprot.skip(ftype)
15149 
      iprot.readFieldEnd()
15150 
    iprot.readStructEnd()
15151 
 
15152 
  def write(self, oprot):
15153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15155 
      return
15156 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15157 
    if self.success is not None:
2591 chandransh 15158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15159 
      oprot.writeBool(self.success)
15160 
      oprot.writeFieldEnd()
3431 rajveer 15161 
    if self.ex is not None:
2591 chandransh 15162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15163 
      self.ex.write(oprot)
15164 
      oprot.writeFieldEnd()
15165 
    oprot.writeFieldStop()
15166 
    oprot.writeStructEnd()
15167 
 
3431 rajveer 15168 
  def validate(self):
15169 
    return
15170 
 
15171 
 
2591 chandransh 15172 
  def __repr__(self):
15173 
    L = ['%s=%r' % (key, value)
15174 
      for key, value in self.__dict__.iteritems()]
15175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15176 
 
15177 
  def __eq__(self, other):
15178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15179 
 
15180 
  def __ne__(self, other):
15181 
    return not (self == other)
15182 
 
4495 rajveer 15183 
class validateReturnProduct_args:
15184 
  """
15185 
  Attributes:
15186 
   - orderId
15187 
   - isUsable
15188 
  """
15189 
 
15190 
  thrift_spec = (
15191 
    None, # 0
15192 
    (1, TType.I64, 'orderId', None, None, ), # 1
15193 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15194 
  )
15195 
 
15196 
  def __init__(self, orderId=None, isUsable=None,):
15197 
    self.orderId = orderId
15198 
    self.isUsable = isUsable
15199 
 
15200 
  def read(self, iprot):
15201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15203 
      return
15204 
    iprot.readStructBegin()
15205 
    while True:
15206 
      (fname, ftype, fid) = iprot.readFieldBegin()
15207 
      if ftype == TType.STOP:
15208 
        break
15209 
      if fid == 1:
15210 
        if ftype == TType.I64:
15211 
          self.orderId = iprot.readI64();
15212 
        else:
15213 
          iprot.skip(ftype)
15214 
      elif fid == 2:
15215 
        if ftype == TType.BOOL:
15216 
          self.isUsable = iprot.readBool();
15217 
        else:
15218 
          iprot.skip(ftype)
15219 
      else:
15220 
        iprot.skip(ftype)
15221 
      iprot.readFieldEnd()
15222 
    iprot.readStructEnd()
15223 
 
15224 
  def write(self, oprot):
15225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15227 
      return
15228 
    oprot.writeStructBegin('validateReturnProduct_args')
15229 
    if self.orderId is not None:
15230 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15231 
      oprot.writeI64(self.orderId)
15232 
      oprot.writeFieldEnd()
15233 
    if self.isUsable is not None:
15234 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15235 
      oprot.writeBool(self.isUsable)
15236 
      oprot.writeFieldEnd()
15237 
    oprot.writeFieldStop()
15238 
    oprot.writeStructEnd()
15239 
 
15240 
  def validate(self):
15241 
    return
15242 
 
15243 
 
15244 
  def __repr__(self):
15245 
    L = ['%s=%r' % (key, value)
15246 
      for key, value in self.__dict__.iteritems()]
15247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15248 
 
15249 
  def __eq__(self, other):
15250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15251 
 
15252 
  def __ne__(self, other):
15253 
    return not (self == other)
15254 
 
15255 
class validateReturnProduct_result:
15256 
  """
15257 
  Attributes:
15258 
   - success
15259 
   - ex
15260 
  """
15261 
 
15262 
  thrift_spec = (
15263 
    (0, TType.BOOL, 'success', None, None, ), # 0
15264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15265 
  )
15266 
 
15267 
  def __init__(self, success=None, ex=None,):
15268 
    self.success = success
15269 
    self.ex = ex
15270 
 
15271 
  def read(self, iprot):
15272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15274 
      return
15275 
    iprot.readStructBegin()
15276 
    while True:
15277 
      (fname, ftype, fid) = iprot.readFieldBegin()
15278 
      if ftype == TType.STOP:
15279 
        break
15280 
      if fid == 0:
15281 
        if ftype == TType.BOOL:
15282 
          self.success = iprot.readBool();
15283 
        else:
15284 
          iprot.skip(ftype)
15285 
      elif fid == 1:
15286 
        if ftype == TType.STRUCT:
15287 
          self.ex = TransactionServiceException()
15288 
          self.ex.read(iprot)
15289 
        else:
15290 
          iprot.skip(ftype)
15291 
      else:
15292 
        iprot.skip(ftype)
15293 
      iprot.readFieldEnd()
15294 
    iprot.readStructEnd()
15295 
 
15296 
  def write(self, oprot):
15297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15299 
      return
15300 
    oprot.writeStructBegin('validateReturnProduct_result')
15301 
    if self.success is not None:
15302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15303 
      oprot.writeBool(self.success)
15304 
      oprot.writeFieldEnd()
15305 
    if self.ex is not None:
15306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15307 
      self.ex.write(oprot)
15308 
      oprot.writeFieldEnd()
15309 
    oprot.writeFieldStop()
15310 
    oprot.writeStructEnd()
15311 
 
15312 
  def validate(self):
15313 
    return
15314 
 
15315 
 
15316 
  def __repr__(self):
15317 
    L = ['%s=%r' % (key, value)
15318 
      for key, value in self.__dict__.iteritems()]
15319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15320 
 
15321 
  def __eq__(self, other):
15322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15323 
 
15324 
  def __ne__(self, other):
15325 
    return not (self == other)
15326 
 
2616 chandransh 15327 
class reshipOrder_args:
15328 
  """
15329 
  Attributes:
15330 
   - orderId
15331 
  """
2591 chandransh 15332 
 
2616 chandransh 15333 
  thrift_spec = (
15334 
    None, # 0
15335 
    (1, TType.I64, 'orderId', None, None, ), # 1
15336 
  )
15337 
 
15338 
  def __init__(self, orderId=None,):
15339 
    self.orderId = orderId
15340 
 
15341 
  def read(self, iprot):
15342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15344 
      return
15345 
    iprot.readStructBegin()
15346 
    while True:
15347 
      (fname, ftype, fid) = iprot.readFieldBegin()
15348 
      if ftype == TType.STOP:
15349 
        break
15350 
      if fid == 1:
15351 
        if ftype == TType.I64:
15352 
          self.orderId = iprot.readI64();
15353 
        else:
15354 
          iprot.skip(ftype)
15355 
      else:
15356 
        iprot.skip(ftype)
15357 
      iprot.readFieldEnd()
15358 
    iprot.readStructEnd()
15359 
 
15360 
  def write(self, oprot):
15361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15363 
      return
15364 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15365 
    if self.orderId is not None:
2616 chandransh 15366 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15367 
      oprot.writeI64(self.orderId)
15368 
      oprot.writeFieldEnd()
15369 
    oprot.writeFieldStop()
15370 
    oprot.writeStructEnd()
15371 
 
3431 rajveer 15372 
  def validate(self):
15373 
    return
15374 
 
15375 
 
2616 chandransh 15376 
  def __repr__(self):
15377 
    L = ['%s=%r' % (key, value)
15378 
      for key, value in self.__dict__.iteritems()]
15379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15380 
 
15381 
  def __eq__(self, other):
15382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15383 
 
15384 
  def __ne__(self, other):
15385 
    return not (self == other)
15386 
 
15387 
class reshipOrder_result:
15388 
  """
15389 
  Attributes:
15390 
   - success
15391 
   - ex
15392 
  """
15393 
 
15394 
  thrift_spec = (
15395 
    (0, TType.I64, 'success', None, None, ), # 0
15396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15397 
  )
15398 
 
15399 
  def __init__(self, success=None, ex=None,):
15400 
    self.success = success
15401 
    self.ex = ex
15402 
 
15403 
  def read(self, iprot):
15404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15406 
      return
15407 
    iprot.readStructBegin()
15408 
    while True:
15409 
      (fname, ftype, fid) = iprot.readFieldBegin()
15410 
      if ftype == TType.STOP:
15411 
        break
15412 
      if fid == 0:
15413 
        if ftype == TType.I64:
15414 
          self.success = iprot.readI64();
15415 
        else:
15416 
          iprot.skip(ftype)
15417 
      elif fid == 1:
15418 
        if ftype == TType.STRUCT:
15419 
          self.ex = TransactionServiceException()
15420 
          self.ex.read(iprot)
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      else:
15424 
        iprot.skip(ftype)
15425 
      iprot.readFieldEnd()
15426 
    iprot.readStructEnd()
15427 
 
15428 
  def write(self, oprot):
15429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15431 
      return
15432 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15433 
    if self.success is not None:
2616 chandransh 15434 
      oprot.writeFieldBegin('success', TType.I64, 0)
15435 
      oprot.writeI64(self.success)
15436 
      oprot.writeFieldEnd()
3431 rajveer 15437 
    if self.ex is not None:
2616 chandransh 15438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15439 
      self.ex.write(oprot)
15440 
      oprot.writeFieldEnd()
15441 
    oprot.writeFieldStop()
15442 
    oprot.writeStructEnd()
15443 
 
3431 rajveer 15444 
  def validate(self):
15445 
    return
15446 
 
15447 
 
2616 chandransh 15448 
  def __repr__(self):
15449 
    L = ['%s=%r' % (key, value)
15450 
      for key, value in self.__dict__.iteritems()]
15451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15452 
 
15453 
  def __eq__(self, other):
15454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15455 
 
15456 
  def __ne__(self, other):
15457 
    return not (self == other)
15458 
 
15459 
class refundOrder_args:
15460 
  """
15461 
  Attributes:
15462 
   - orderId
3226 chandransh 15463 
   - refundedBy
15464 
   - reason
2616 chandransh 15465 
  """
15466 
 
15467 
  thrift_spec = (
15468 
    None, # 0
15469 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15470 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15471 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15472 
  )
15473 
 
3226 chandransh 15474 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15475 
    self.orderId = orderId
3226 chandransh 15476 
    self.refundedBy = refundedBy
15477 
    self.reason = reason
2616 chandransh 15478 
 
15479 
  def read(self, iprot):
15480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15482 
      return
15483 
    iprot.readStructBegin()
15484 
    while True:
15485 
      (fname, ftype, fid) = iprot.readFieldBegin()
15486 
      if ftype == TType.STOP:
15487 
        break
15488 
      if fid == 1:
15489 
        if ftype == TType.I64:
15490 
          self.orderId = iprot.readI64();
15491 
        else:
15492 
          iprot.skip(ftype)
3226 chandransh 15493 
      elif fid == 2:
15494 
        if ftype == TType.STRING:
15495 
          self.refundedBy = iprot.readString();
15496 
        else:
15497 
          iprot.skip(ftype)
15498 
      elif fid == 3:
15499 
        if ftype == TType.STRING:
15500 
          self.reason = iprot.readString();
15501 
        else:
15502 
          iprot.skip(ftype)
2616 chandransh 15503 
      else:
15504 
        iprot.skip(ftype)
15505 
      iprot.readFieldEnd()
15506 
    iprot.readStructEnd()
15507 
 
15508 
  def write(self, oprot):
15509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15511 
      return
15512 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15513 
    if self.orderId is not None:
2616 chandransh 15514 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15515 
      oprot.writeI64(self.orderId)
15516 
      oprot.writeFieldEnd()
3431 rajveer 15517 
    if self.refundedBy is not None:
3226 chandransh 15518 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15519 
      oprot.writeString(self.refundedBy)
15520 
      oprot.writeFieldEnd()
3431 rajveer 15521 
    if self.reason is not None:
3226 chandransh 15522 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15523 
      oprot.writeString(self.reason)
15524 
      oprot.writeFieldEnd()
2616 chandransh 15525 
    oprot.writeFieldStop()
15526 
    oprot.writeStructEnd()
15527 
 
3431 rajveer 15528 
  def validate(self):
15529 
    return
15530 
 
15531 
 
2616 chandransh 15532 
  def __repr__(self):
15533 
    L = ['%s=%r' % (key, value)
15534 
      for key, value in self.__dict__.iteritems()]
15535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15536 
 
15537 
  def __eq__(self, other):
15538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15539 
 
15540 
  def __ne__(self, other):
15541 
    return not (self == other)
15542 
 
15543 
class refundOrder_result:
15544 
  """
15545 
  Attributes:
15546 
   - success
15547 
   - ex
15548 
  """
15549 
 
15550 
  thrift_spec = (
15551 
    (0, TType.BOOL, 'success', None, None, ), # 0
15552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15553 
  )
15554 
 
15555 
  def __init__(self, success=None, ex=None,):
15556 
    self.success = success
15557 
    self.ex = ex
15558 
 
15559 
  def read(self, iprot):
15560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15562 
      return
15563 
    iprot.readStructBegin()
15564 
    while True:
15565 
      (fname, ftype, fid) = iprot.readFieldBegin()
15566 
      if ftype == TType.STOP:
15567 
        break
15568 
      if fid == 0:
15569 
        if ftype == TType.BOOL:
15570 
          self.success = iprot.readBool();
15571 
        else:
15572 
          iprot.skip(ftype)
15573 
      elif fid == 1:
15574 
        if ftype == TType.STRUCT:
15575 
          self.ex = TransactionServiceException()
15576 
          self.ex.read(iprot)
15577 
        else:
15578 
          iprot.skip(ftype)
15579 
      else:
15580 
        iprot.skip(ftype)
15581 
      iprot.readFieldEnd()
15582 
    iprot.readStructEnd()
15583 
 
15584 
  def write(self, oprot):
15585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15587 
      return
15588 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15589 
    if self.success is not None:
2616 chandransh 15590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15591 
      oprot.writeBool(self.success)
15592 
      oprot.writeFieldEnd()
3431 rajveer 15593 
    if self.ex is not None:
2616 chandransh 15594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15595 
      self.ex.write(oprot)
15596 
      oprot.writeFieldEnd()
15597 
    oprot.writeFieldStop()
15598 
    oprot.writeStructEnd()
15599 
 
3431 rajveer 15600 
  def validate(self):
15601 
    return
15602 
 
15603 
 
2616 chandransh 15604 
  def __repr__(self):
15605 
    L = ['%s=%r' % (key, value)
15606 
      for key, value in self.__dict__.iteritems()]
15607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15608 
 
15609 
  def __eq__(self, other):
15610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15611 
 
15612 
  def __ne__(self, other):
15613 
    return not (self == other)
15614 
 
2690 chandransh 15615 
class getReturnOrders_args:
15616 
  """
15617 
  Attributes:
15618 
   - warehouseId
15619 
   - fromDate
15620 
   - toDate
15621 
  """
2616 chandransh 15622 
 
2690 chandransh 15623 
  thrift_spec = (
15624 
    None, # 0
15625 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15626 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15627 
    (3, TType.I64, 'toDate', None, None, ), # 3
15628 
  )
15629 
 
15630 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15631 
    self.warehouseId = warehouseId
15632 
    self.fromDate = fromDate
15633 
    self.toDate = toDate
15634 
 
15635 
  def read(self, iprot):
15636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15638 
      return
15639 
    iprot.readStructBegin()
15640 
    while True:
15641 
      (fname, ftype, fid) = iprot.readFieldBegin()
15642 
      if ftype == TType.STOP:
15643 
        break
15644 
      if fid == 1:
15645 
        if ftype == TType.I64:
15646 
          self.warehouseId = iprot.readI64();
15647 
        else:
15648 
          iprot.skip(ftype)
15649 
      elif fid == 2:
15650 
        if ftype == TType.I64:
15651 
          self.fromDate = iprot.readI64();
15652 
        else:
15653 
          iprot.skip(ftype)
15654 
      elif fid == 3:
15655 
        if ftype == TType.I64:
15656 
          self.toDate = iprot.readI64();
15657 
        else:
15658 
          iprot.skip(ftype)
15659 
      else:
15660 
        iprot.skip(ftype)
15661 
      iprot.readFieldEnd()
15662 
    iprot.readStructEnd()
15663 
 
15664 
  def write(self, oprot):
15665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15667 
      return
15668 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 15669 
    if self.warehouseId is not None:
2690 chandransh 15670 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15671 
      oprot.writeI64(self.warehouseId)
15672 
      oprot.writeFieldEnd()
3431 rajveer 15673 
    if self.fromDate is not None:
2690 chandransh 15674 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
15675 
      oprot.writeI64(self.fromDate)
15676 
      oprot.writeFieldEnd()
3431 rajveer 15677 
    if self.toDate is not None:
2690 chandransh 15678 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
15679 
      oprot.writeI64(self.toDate)
15680 
      oprot.writeFieldEnd()
15681 
    oprot.writeFieldStop()
15682 
    oprot.writeStructEnd()
15683 
 
3431 rajveer 15684 
  def validate(self):
15685 
    return
15686 
 
15687 
 
2690 chandransh 15688 
  def __repr__(self):
15689 
    L = ['%s=%r' % (key, value)
15690 
      for key, value in self.__dict__.iteritems()]
15691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15692 
 
15693 
  def __eq__(self, other):
15694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15695 
 
15696 
  def __ne__(self, other):
15697 
    return not (self == other)
15698 
 
15699 
class getReturnOrders_result:
15700 
  """
15701 
  Attributes:
15702 
   - success
15703 
  """
15704 
 
15705 
  thrift_spec = (
15706 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
15707 
  )
15708 
 
15709 
  def __init__(self, success=None,):
15710 
    self.success = success
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      if fid == 0:
15722 
        if ftype == TType.LIST:
15723 
          self.success = []
4910 phani.kuma 15724 
          (_etype322, _size319) = iprot.readListBegin()
15725 
          for _i323 in xrange(_size319):
15726 
            _elem324 = ReturnOrder()
15727 
            _elem324.read(iprot)
15728 
            self.success.append(_elem324)
2690 chandransh 15729 
          iprot.readListEnd()
15730 
        else:
15731 
          iprot.skip(ftype)
15732 
      else:
15733 
        iprot.skip(ftype)
15734 
      iprot.readFieldEnd()
15735 
    iprot.readStructEnd()
15736 
 
15737 
  def write(self, oprot):
15738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15740 
      return
15741 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 15742 
    if self.success is not None:
2690 chandransh 15743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 15745 
      for iter325 in self.success:
15746 
        iter325.write(oprot)
2690 chandransh 15747 
      oprot.writeListEnd()
15748 
      oprot.writeFieldEnd()
15749 
    oprot.writeFieldStop()
15750 
    oprot.writeStructEnd()
15751 
 
3431 rajveer 15752 
  def validate(self):
15753 
    return
15754 
 
15755 
 
2690 chandransh 15756 
  def __repr__(self):
15757 
    L = ['%s=%r' % (key, value)
15758 
      for key, value in self.__dict__.iteritems()]
15759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15760 
 
15761 
  def __eq__(self, other):
15762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15763 
 
15764 
  def __ne__(self, other):
15765 
    return not (self == other)
15766 
 
2700 chandransh 15767 
class getReturnOrder_args:
15768 
  """
15769 
  Attributes:
15770 
   - id
15771 
  """
15772 
 
15773 
  thrift_spec = (
15774 
    None, # 0
15775 
    (1, TType.I64, 'id', None, None, ), # 1
15776 
  )
15777 
 
15778 
  def __init__(self, id=None,):
15779 
    self.id = id
15780 
 
15781 
  def read(self, iprot):
15782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15784 
      return
15785 
    iprot.readStructBegin()
15786 
    while True:
15787 
      (fname, ftype, fid) = iprot.readFieldBegin()
15788 
      if ftype == TType.STOP:
15789 
        break
15790 
      if fid == 1:
15791 
        if ftype == TType.I64:
15792 
          self.id = iprot.readI64();
15793 
        else:
15794 
          iprot.skip(ftype)
15795 
      else:
15796 
        iprot.skip(ftype)
15797 
      iprot.readFieldEnd()
15798 
    iprot.readStructEnd()
15799 
 
15800 
  def write(self, oprot):
15801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15803 
      return
15804 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 15805 
    if self.id is not None:
2700 chandransh 15806 
      oprot.writeFieldBegin('id', TType.I64, 1)
15807 
      oprot.writeI64(self.id)
15808 
      oprot.writeFieldEnd()
15809 
    oprot.writeFieldStop()
15810 
    oprot.writeStructEnd()
15811 
 
3431 rajveer 15812 
  def validate(self):
15813 
    return
15814 
 
15815 
 
2700 chandransh 15816 
  def __repr__(self):
15817 
    L = ['%s=%r' % (key, value)
15818 
      for key, value in self.__dict__.iteritems()]
15819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15820 
 
15821 
  def __eq__(self, other):
15822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15823 
 
15824 
  def __ne__(self, other):
15825 
    return not (self == other)
15826 
 
15827 
class getReturnOrder_result:
15828 
  """
15829 
  Attributes:
15830 
   - success
15831 
   - ex
15832 
  """
15833 
 
15834 
  thrift_spec = (
15835 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
15836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15837 
  )
15838 
 
15839 
  def __init__(self, success=None, ex=None,):
15840 
    self.success = success
15841 
    self.ex = ex
15842 
 
15843 
  def read(self, iprot):
15844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15846 
      return
15847 
    iprot.readStructBegin()
15848 
    while True:
15849 
      (fname, ftype, fid) = iprot.readFieldBegin()
15850 
      if ftype == TType.STOP:
15851 
        break
15852 
      if fid == 0:
15853 
        if ftype == TType.STRUCT:
15854 
          self.success = ReturnOrder()
15855 
          self.success.read(iprot)
15856 
        else:
15857 
          iprot.skip(ftype)
15858 
      elif fid == 1:
15859 
        if ftype == TType.STRUCT:
15860 
          self.ex = TransactionServiceException()
15861 
          self.ex.read(iprot)
15862 
        else:
15863 
          iprot.skip(ftype)
15864 
      else:
15865 
        iprot.skip(ftype)
15866 
      iprot.readFieldEnd()
15867 
    iprot.readStructEnd()
15868 
 
15869 
  def write(self, oprot):
15870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15872 
      return
15873 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 15874 
    if self.success is not None:
2700 chandransh 15875 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15876 
      self.success.write(oprot)
15877 
      oprot.writeFieldEnd()
3431 rajveer 15878 
    if self.ex is not None:
2700 chandransh 15879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15880 
      self.ex.write(oprot)
15881 
      oprot.writeFieldEnd()
15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
3431 rajveer 15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
2700 chandransh 15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
15899 
 
2690 chandransh 15900 
class processReturn_args:
15901 
  """
15902 
  Attributes:
15903 
   - returnOrderId
15904 
  """
15905 
 
15906 
  thrift_spec = (
15907 
    None, # 0
15908 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
15909 
  )
15910 
 
15911 
  def __init__(self, returnOrderId=None,):
15912 
    self.returnOrderId = returnOrderId
15913 
 
15914 
  def read(self, iprot):
15915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15917 
      return
15918 
    iprot.readStructBegin()
15919 
    while True:
15920 
      (fname, ftype, fid) = iprot.readFieldBegin()
15921 
      if ftype == TType.STOP:
15922 
        break
15923 
      if fid == 1:
15924 
        if ftype == TType.I64:
15925 
          self.returnOrderId = iprot.readI64();
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
15937 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 15938 
    if self.returnOrderId is not None:
2690 chandransh 15939 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
15940 
      oprot.writeI64(self.returnOrderId)
15941 
      oprot.writeFieldEnd()
15942 
    oprot.writeFieldStop()
15943 
    oprot.writeStructEnd()
15944 
 
3431 rajveer 15945 
  def validate(self):
15946 
    return
15947 
 
15948 
 
2690 chandransh 15949 
  def __repr__(self):
15950 
    L = ['%s=%r' % (key, value)
15951 
      for key, value in self.__dict__.iteritems()]
15952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15953 
 
15954 
  def __eq__(self, other):
15955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15956 
 
15957 
  def __ne__(self, other):
15958 
    return not (self == other)
15959 
 
15960 
class processReturn_result:
15961 
  """
15962 
  Attributes:
15963 
   - ex
15964 
  """
15965 
 
15966 
  thrift_spec = (
15967 
    None, # 0
15968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15969 
  )
15970 
 
15971 
  def __init__(self, ex=None,):
15972 
    self.ex = ex
15973 
 
15974 
  def read(self, iprot):
15975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15977 
      return
15978 
    iprot.readStructBegin()
15979 
    while True:
15980 
      (fname, ftype, fid) = iprot.readFieldBegin()
15981 
      if ftype == TType.STOP:
15982 
        break
15983 
      if fid == 1:
15984 
        if ftype == TType.STRUCT:
15985 
          self.ex = TransactionServiceException()
15986 
          self.ex.read(iprot)
15987 
        else:
15988 
          iprot.skip(ftype)
15989 
      else:
15990 
        iprot.skip(ftype)
15991 
      iprot.readFieldEnd()
15992 
    iprot.readStructEnd()
15993 
 
15994 
  def write(self, oprot):
15995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15997 
      return
15998 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 15999 
    if self.ex is not None:
2690 chandransh 16000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16001 
      self.ex.write(oprot)
16002 
      oprot.writeFieldEnd()
16003 
    oprot.writeFieldStop()
16004 
    oprot.writeStructEnd()
16005 
 
3431 rajveer 16006 
  def validate(self):
16007 
    return
16008 
 
16009 
 
2690 chandransh 16010 
  def __repr__(self):
16011 
    L = ['%s=%r' % (key, value)
16012 
      for key, value in self.__dict__.iteritems()]
16013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16014 
 
16015 
  def __eq__(self, other):
16016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16017 
 
16018 
  def __ne__(self, other):
16019 
    return not (self == other)
16020 
 
3451 chandransh 16021 
class updateWeight_args:
16022 
  """
16023 
  Attributes:
16024 
   - orderId
16025 
   - weight
16026 
  """
16027 
 
16028 
  thrift_spec = (
16029 
    None, # 0
16030 
    (1, TType.I64, 'orderId', None, None, ), # 1
16031 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16032 
  )
16033 
 
16034 
  def __init__(self, orderId=None, weight=None,):
16035 
    self.orderId = orderId
16036 
    self.weight = weight
16037 
 
16038 
  def read(self, iprot):
16039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16041 
      return
16042 
    iprot.readStructBegin()
16043 
    while True:
16044 
      (fname, ftype, fid) = iprot.readFieldBegin()
16045 
      if ftype == TType.STOP:
16046 
        break
16047 
      if fid == 1:
16048 
        if ftype == TType.I64:
16049 
          self.orderId = iprot.readI64();
16050 
        else:
16051 
          iprot.skip(ftype)
16052 
      elif fid == 2:
16053 
        if ftype == TType.DOUBLE:
16054 
          self.weight = iprot.readDouble();
16055 
        else:
16056 
          iprot.skip(ftype)
16057 
      else:
16058 
        iprot.skip(ftype)
16059 
      iprot.readFieldEnd()
16060 
    iprot.readStructEnd()
16061 
 
16062 
  def write(self, oprot):
16063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16065 
      return
16066 
    oprot.writeStructBegin('updateWeight_args')
16067 
    if self.orderId is not None:
16068 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16069 
      oprot.writeI64(self.orderId)
16070 
      oprot.writeFieldEnd()
16071 
    if self.weight is not None:
16072 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16073 
      oprot.writeDouble(self.weight)
16074 
      oprot.writeFieldEnd()
16075 
    oprot.writeFieldStop()
16076 
    oprot.writeStructEnd()
16077 
 
16078 
  def validate(self):
16079 
    return
16080 
 
16081 
 
16082 
  def __repr__(self):
16083 
    L = ['%s=%r' % (key, value)
16084 
      for key, value in self.__dict__.iteritems()]
16085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16086 
 
16087 
  def __eq__(self, other):
16088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16089 
 
16090 
  def __ne__(self, other):
16091 
    return not (self == other)
16092 
 
16093 
class updateWeight_result:
16094 
  """
16095 
  Attributes:
16096 
   - success
16097 
   - ex
16098 
  """
16099 
 
16100 
  thrift_spec = (
16101 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16103 
  )
16104 
 
16105 
  def __init__(self, success=None, ex=None,):
16106 
    self.success = success
16107 
    self.ex = ex
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      if fid == 0:
16119 
        if ftype == TType.STRUCT:
16120 
          self.success = Order()
16121 
          self.success.read(iprot)
16122 
        else:
16123 
          iprot.skip(ftype)
16124 
      elif fid == 1:
16125 
        if ftype == TType.STRUCT:
16126 
          self.ex = TransactionServiceException()
16127 
          self.ex.read(iprot)
16128 
        else:
16129 
          iprot.skip(ftype)
16130 
      else:
16131 
        iprot.skip(ftype)
16132 
      iprot.readFieldEnd()
16133 
    iprot.readStructEnd()
16134 
 
16135 
  def write(self, oprot):
16136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16138 
      return
16139 
    oprot.writeStructBegin('updateWeight_result')
16140 
    if self.success is not None:
16141 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16142 
      self.success.write(oprot)
16143 
      oprot.writeFieldEnd()
16144 
    if self.ex is not None:
16145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16146 
      self.ex.write(oprot)
16147 
      oprot.writeFieldEnd()
16148 
    oprot.writeFieldStop()
16149 
    oprot.writeStructEnd()
16150 
 
16151 
  def validate(self):
16152 
    return
16153 
 
16154 
 
16155 
  def __repr__(self):
16156 
    L = ['%s=%r' % (key, value)
16157 
      for key, value in self.__dict__.iteritems()]
16158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16159 
 
16160 
  def __eq__(self, other):
16161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16162 
 
16163 
  def __ne__(self, other):
16164 
    return not (self == other)
3469 chandransh 16165 
 
16166 
class changeItem_args:
16167 
  """
16168 
  Attributes:
16169 
   - orderId
16170 
   - itemId
16171 
  """
16172 
 
16173 
  thrift_spec = (
16174 
    None, # 0
16175 
    (1, TType.I64, 'orderId', None, None, ), # 1
16176 
    (2, TType.I64, 'itemId', None, None, ), # 2
16177 
  )
16178 
 
16179 
  def __init__(self, orderId=None, itemId=None,):
16180 
    self.orderId = orderId
16181 
    self.itemId = itemId
16182 
 
16183 
  def read(self, iprot):
16184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16186 
      return
16187 
    iprot.readStructBegin()
16188 
    while True:
16189 
      (fname, ftype, fid) = iprot.readFieldBegin()
16190 
      if ftype == TType.STOP:
16191 
        break
16192 
      if fid == 1:
16193 
        if ftype == TType.I64:
16194 
          self.orderId = iprot.readI64();
16195 
        else:
16196 
          iprot.skip(ftype)
16197 
      elif fid == 2:
16198 
        if ftype == TType.I64:
16199 
          self.itemId = iprot.readI64();
16200 
        else:
16201 
          iprot.skip(ftype)
16202 
      else:
16203 
        iprot.skip(ftype)
16204 
      iprot.readFieldEnd()
16205 
    iprot.readStructEnd()
16206 
 
16207 
  def write(self, oprot):
16208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16210 
      return
16211 
    oprot.writeStructBegin('changeItem_args')
16212 
    if self.orderId is not None:
16213 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16214 
      oprot.writeI64(self.orderId)
16215 
      oprot.writeFieldEnd()
16216 
    if self.itemId is not None:
16217 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16218 
      oprot.writeI64(self.itemId)
16219 
      oprot.writeFieldEnd()
16220 
    oprot.writeFieldStop()
16221 
    oprot.writeStructEnd()
16222 
 
16223 
  def validate(self):
16224 
    return
16225 
 
16226 
 
16227 
  def __repr__(self):
16228 
    L = ['%s=%r' % (key, value)
16229 
      for key, value in self.__dict__.iteritems()]
16230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16231 
 
16232 
  def __eq__(self, other):
16233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16234 
 
16235 
  def __ne__(self, other):
16236 
    return not (self == other)
16237 
 
16238 
class changeItem_result:
16239 
  """
16240 
  Attributes:
16241 
   - success
16242 
   - ex
16243 
  """
16244 
 
16245 
  thrift_spec = (
16246 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16248 
  )
16249 
 
16250 
  def __init__(self, success=None, ex=None,):
16251 
    self.success = success
16252 
    self.ex = ex
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      if fid == 0:
16264 
        if ftype == TType.STRUCT:
16265 
          self.success = Order()
16266 
          self.success.read(iprot)
16267 
        else:
16268 
          iprot.skip(ftype)
16269 
      elif fid == 1:
16270 
        if ftype == TType.STRUCT:
16271 
          self.ex = TransactionServiceException()
16272 
          self.ex.read(iprot)
16273 
        else:
16274 
          iprot.skip(ftype)
16275 
      else:
16276 
        iprot.skip(ftype)
16277 
      iprot.readFieldEnd()
16278 
    iprot.readStructEnd()
16279 
 
16280 
  def write(self, oprot):
16281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16283 
      return
16284 
    oprot.writeStructBegin('changeItem_result')
16285 
    if self.success is not None:
16286 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16287 
      self.success.write(oprot)
16288 
      oprot.writeFieldEnd()
16289 
    if self.ex is not None:
16290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16291 
      self.ex.write(oprot)
16292 
      oprot.writeFieldEnd()
16293 
    oprot.writeFieldStop()
16294 
    oprot.writeStructEnd()
16295 
 
16296 
  def validate(self):
16297 
    return
16298 
 
16299 
 
16300 
  def __repr__(self):
16301 
    L = ['%s=%r' % (key, value)
16302 
      for key, value in self.__dict__.iteritems()]
16303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16304 
 
16305 
  def __eq__(self, other):
16306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16307 
 
16308 
  def __ne__(self, other):
16309 
    return not (self == other)
16310 
 
16311 
class shiftToWarehouse_args:
16312 
  """
16313 
  Attributes:
16314 
   - orderId
16315 
   - warehouseId
16316 
  """
16317 
 
16318 
  thrift_spec = (
16319 
    None, # 0
16320 
    (1, TType.I64, 'orderId', None, None, ), # 1
16321 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16322 
  )
16323 
 
16324 
  def __init__(self, orderId=None, warehouseId=None,):
16325 
    self.orderId = orderId
16326 
    self.warehouseId = warehouseId
16327 
 
16328 
  def read(self, iprot):
16329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16331 
      return
16332 
    iprot.readStructBegin()
16333 
    while True:
16334 
      (fname, ftype, fid) = iprot.readFieldBegin()
16335 
      if ftype == TType.STOP:
16336 
        break
16337 
      if fid == 1:
16338 
        if ftype == TType.I64:
16339 
          self.orderId = iprot.readI64();
16340 
        else:
16341 
          iprot.skip(ftype)
16342 
      elif fid == 2:
16343 
        if ftype == TType.I64:
16344 
          self.warehouseId = iprot.readI64();
16345 
        else:
16346 
          iprot.skip(ftype)
16347 
      else:
16348 
        iprot.skip(ftype)
16349 
      iprot.readFieldEnd()
16350 
    iprot.readStructEnd()
16351 
 
16352 
  def write(self, oprot):
16353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16355 
      return
16356 
    oprot.writeStructBegin('shiftToWarehouse_args')
16357 
    if self.orderId is not None:
16358 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16359 
      oprot.writeI64(self.orderId)
16360 
      oprot.writeFieldEnd()
16361 
    if self.warehouseId is not None:
16362 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16363 
      oprot.writeI64(self.warehouseId)
16364 
      oprot.writeFieldEnd()
16365 
    oprot.writeFieldStop()
16366 
    oprot.writeStructEnd()
16367 
 
16368 
  def validate(self):
16369 
    return
16370 
 
16371 
 
16372 
  def __repr__(self):
16373 
    L = ['%s=%r' % (key, value)
16374 
      for key, value in self.__dict__.iteritems()]
16375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16376 
 
16377 
  def __eq__(self, other):
16378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16379 
 
16380 
  def __ne__(self, other):
16381 
    return not (self == other)
16382 
 
16383 
class shiftToWarehouse_result:
16384 
  """
16385 
  Attributes:
16386 
   - success
16387 
   - ex
16388 
  """
16389 
 
16390 
  thrift_spec = (
16391 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16393 
  )
16394 
 
16395 
  def __init__(self, success=None, ex=None,):
16396 
    self.success = success
16397 
    self.ex = ex
16398 
 
16399 
  def read(self, iprot):
16400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16402 
      return
16403 
    iprot.readStructBegin()
16404 
    while True:
16405 
      (fname, ftype, fid) = iprot.readFieldBegin()
16406 
      if ftype == TType.STOP:
16407 
        break
16408 
      if fid == 0:
16409 
        if ftype == TType.STRUCT:
16410 
          self.success = Order()
16411 
          self.success.read(iprot)
16412 
        else:
16413 
          iprot.skip(ftype)
16414 
      elif fid == 1:
16415 
        if ftype == TType.STRUCT:
16416 
          self.ex = TransactionServiceException()
16417 
          self.ex.read(iprot)
16418 
        else:
16419 
          iprot.skip(ftype)
16420 
      else:
16421 
        iprot.skip(ftype)
16422 
      iprot.readFieldEnd()
16423 
    iprot.readStructEnd()
16424 
 
16425 
  def write(self, oprot):
16426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16428 
      return
16429 
    oprot.writeStructBegin('shiftToWarehouse_result')
16430 
    if self.success is not None:
16431 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16432 
      self.success.write(oprot)
16433 
      oprot.writeFieldEnd()
16434 
    if self.ex is not None:
16435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16436 
      self.ex.write(oprot)
16437 
      oprot.writeFieldEnd()
16438 
    oprot.writeFieldStop()
16439 
    oprot.writeStructEnd()
16440 
 
16441 
  def validate(self):
16442 
    return
16443 
 
16444 
 
16445 
  def __repr__(self):
16446 
    L = ['%s=%r' % (key, value)
16447 
      for key, value in self.__dict__.iteritems()]
16448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16449 
 
16450 
  def __eq__(self, other):
16451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16452 
 
16453 
  def __ne__(self, other):
16454 
    return not (self == other)
3553 chandransh 16455 
 
16456 
class addDelayReason_args:
16457 
  """
16458 
  Attributes:
16459 
   - orderId
16460 
   - delayReason
3986 chandransh 16461 
   - furtherDelay
4647 rajveer 16462 
   - delayReasonText
3553 chandransh 16463 
  """
16464 
 
16465 
  thrift_spec = (
16466 
    None, # 0
16467 
    (1, TType.I64, 'orderId', None, None, ), # 1
16468 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16469 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16470 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16471 
  )
16472 
 
4647 rajveer 16473 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16474 
    self.orderId = orderId
16475 
    self.delayReason = delayReason
3986 chandransh 16476 
    self.furtherDelay = furtherDelay
4647 rajveer 16477 
    self.delayReasonText = delayReasonText
3553 chandransh 16478 
 
16479 
  def read(self, iprot):
16480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16482 
      return
16483 
    iprot.readStructBegin()
16484 
    while True:
16485 
      (fname, ftype, fid) = iprot.readFieldBegin()
16486 
      if ftype == TType.STOP:
16487 
        break
16488 
      if fid == 1:
16489 
        if ftype == TType.I64:
16490 
          self.orderId = iprot.readI64();
16491 
        else:
16492 
          iprot.skip(ftype)
16493 
      elif fid == 2:
16494 
        if ftype == TType.I32:
16495 
          self.delayReason = iprot.readI32();
16496 
        else:
16497 
          iprot.skip(ftype)
3986 chandransh 16498 
      elif fid == 3:
16499 
        if ftype == TType.I64:
16500 
          self.furtherDelay = iprot.readI64();
16501 
        else:
16502 
          iprot.skip(ftype)
4647 rajveer 16503 
      elif fid == 4:
16504 
        if ftype == TType.STRING:
16505 
          self.delayReasonText = iprot.readString();
16506 
        else:
16507 
          iprot.skip(ftype)
3553 chandransh 16508 
      else:
16509 
        iprot.skip(ftype)
16510 
      iprot.readFieldEnd()
16511 
    iprot.readStructEnd()
16512 
 
16513 
  def write(self, oprot):
16514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16516 
      return
16517 
    oprot.writeStructBegin('addDelayReason_args')
16518 
    if self.orderId is not None:
16519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16520 
      oprot.writeI64(self.orderId)
16521 
      oprot.writeFieldEnd()
16522 
    if self.delayReason is not None:
16523 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16524 
      oprot.writeI32(self.delayReason)
16525 
      oprot.writeFieldEnd()
3986 chandransh 16526 
    if self.furtherDelay is not None:
16527 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16528 
      oprot.writeI64(self.furtherDelay)
16529 
      oprot.writeFieldEnd()
4647 rajveer 16530 
    if self.delayReasonText is not None:
16531 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16532 
      oprot.writeString(self.delayReasonText)
16533 
      oprot.writeFieldEnd()
3553 chandransh 16534 
    oprot.writeFieldStop()
16535 
    oprot.writeStructEnd()
16536 
 
16537 
  def validate(self):
16538 
    return
16539 
 
16540 
 
16541 
  def __repr__(self):
16542 
    L = ['%s=%r' % (key, value)
16543 
      for key, value in self.__dict__.iteritems()]
16544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16545 
 
16546 
  def __eq__(self, other):
16547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16548 
 
16549 
  def __ne__(self, other):
16550 
    return not (self == other)
16551 
 
16552 
class addDelayReason_result:
16553 
  """
16554 
  Attributes:
16555 
   - success
16556 
   - ex
16557 
  """
16558 
 
16559 
  thrift_spec = (
16560 
    (0, TType.BOOL, 'success', None, None, ), # 0
16561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16562 
  )
16563 
 
16564 
  def __init__(self, success=None, ex=None,):
16565 
    self.success = success
16566 
    self.ex = ex
16567 
 
16568 
  def read(self, iprot):
16569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16571 
      return
16572 
    iprot.readStructBegin()
16573 
    while True:
16574 
      (fname, ftype, fid) = iprot.readFieldBegin()
16575 
      if ftype == TType.STOP:
16576 
        break
16577 
      if fid == 0:
16578 
        if ftype == TType.BOOL:
16579 
          self.success = iprot.readBool();
16580 
        else:
16581 
          iprot.skip(ftype)
16582 
      elif fid == 1:
16583 
        if ftype == TType.STRUCT:
16584 
          self.ex = TransactionServiceException()
16585 
          self.ex.read(iprot)
16586 
        else:
16587 
          iprot.skip(ftype)
16588 
      else:
16589 
        iprot.skip(ftype)
16590 
      iprot.readFieldEnd()
16591 
    iprot.readStructEnd()
16592 
 
16593 
  def write(self, oprot):
16594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16596 
      return
16597 
    oprot.writeStructBegin('addDelayReason_result')
16598 
    if self.success is not None:
16599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16600 
      oprot.writeBool(self.success)
16601 
      oprot.writeFieldEnd()
16602 
    if self.ex is not None:
16603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16604 
      self.ex.write(oprot)
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
3956 chandransh 16623 
 
16624 
class reconcileCodCollection_args:
16625 
  """
16626 
  Attributes:
16627 
   - collectedAmountMap
16628 
   - xferBy
16629 
   - xferTxnId
16630 
   - xferDate
16631 
  """
16632 
 
16633 
  thrift_spec = (
16634 
    None, # 0
16635 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16636 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16637 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16638 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16639 
  )
16640 
 
16641 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16642 
    self.collectedAmountMap = collectedAmountMap
16643 
    self.xferBy = xferBy
16644 
    self.xferTxnId = xferTxnId
16645 
    self.xferDate = xferDate
16646 
 
16647 
  def read(self, iprot):
16648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16650 
      return
16651 
    iprot.readStructBegin()
16652 
    while True:
16653 
      (fname, ftype, fid) = iprot.readFieldBegin()
16654 
      if ftype == TType.STOP:
16655 
        break
16656 
      if fid == 1:
16657 
        if ftype == TType.MAP:
16658 
          self.collectedAmountMap = {}
4910 phani.kuma 16659 
          (_ktype327, _vtype328, _size326 ) = iprot.readMapBegin()
16660 
          for _i330 in xrange(_size326):
16661 
            _key331 = iprot.readString();
16662 
            _val332 = iprot.readDouble();
16663 
            self.collectedAmountMap[_key331] = _val332
3956 chandransh 16664 
          iprot.readMapEnd()
16665 
        else:
16666 
          iprot.skip(ftype)
16667 
      elif fid == 2:
16668 
        if ftype == TType.STRING:
16669 
          self.xferBy = iprot.readString();
16670 
        else:
16671 
          iprot.skip(ftype)
16672 
      elif fid == 3:
16673 
        if ftype == TType.STRING:
16674 
          self.xferTxnId = iprot.readString();
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      elif fid == 4:
16678 
        if ftype == TType.I64:
16679 
          self.xferDate = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      else:
16683 
        iprot.skip(ftype)
16684 
      iprot.readFieldEnd()
16685 
    iprot.readStructEnd()
16686 
 
16687 
  def write(self, oprot):
16688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16690 
      return
16691 
    oprot.writeStructBegin('reconcileCodCollection_args')
16692 
    if self.collectedAmountMap is not None:
16693 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
16694 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4910 phani.kuma 16695 
      for kiter333,viter334 in self.collectedAmountMap.items():
16696 
        oprot.writeString(kiter333)
16697 
        oprot.writeDouble(viter334)
3956 chandransh 16698 
      oprot.writeMapEnd()
16699 
      oprot.writeFieldEnd()
16700 
    if self.xferBy is not None:
16701 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
16702 
      oprot.writeString(self.xferBy)
16703 
      oprot.writeFieldEnd()
16704 
    if self.xferTxnId is not None:
16705 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
16706 
      oprot.writeString(self.xferTxnId)
16707 
      oprot.writeFieldEnd()
16708 
    if self.xferDate is not None:
16709 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
16710 
      oprot.writeI64(self.xferDate)
16711 
      oprot.writeFieldEnd()
16712 
    oprot.writeFieldStop()
16713 
    oprot.writeStructEnd()
16714 
 
16715 
  def validate(self):
16716 
    return
16717 
 
16718 
 
16719 
  def __repr__(self):
16720 
    L = ['%s=%r' % (key, value)
16721 
      for key, value in self.__dict__.iteritems()]
16722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16723 
 
16724 
  def __eq__(self, other):
16725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16726 
 
16727 
  def __ne__(self, other):
16728 
    return not (self == other)
16729 
 
16730 
class reconcileCodCollection_result:
16731 
  """
16732 
  Attributes:
16733 
   - success
16734 
   - ex
16735 
  """
16736 
 
16737 
  thrift_spec = (
16738 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16740 
  )
16741 
 
16742 
  def __init__(self, success=None, ex=None,):
16743 
    self.success = success
16744 
    self.ex = ex
16745 
 
16746 
  def read(self, iprot):
16747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16749 
      return
16750 
    iprot.readStructBegin()
16751 
    while True:
16752 
      (fname, ftype, fid) = iprot.readFieldBegin()
16753 
      if ftype == TType.STOP:
16754 
        break
16755 
      if fid == 0:
16756 
        if ftype == TType.MAP:
16757 
          self.success = {}
4910 phani.kuma 16758 
          (_ktype336, _vtype337, _size335 ) = iprot.readMapBegin()
16759 
          for _i339 in xrange(_size335):
16760 
            _key340 = iprot.readString();
16761 
            _val341 = iprot.readString();
16762 
            self.success[_key340] = _val341
3956 chandransh 16763 
          iprot.readMapEnd()
16764 
        else:
16765 
          iprot.skip(ftype)
16766 
      elif fid == 1:
16767 
        if ftype == TType.STRUCT:
16768 
          self.ex = TransactionServiceException()
16769 
          self.ex.read(iprot)
16770 
        else:
16771 
          iprot.skip(ftype)
16772 
      else:
16773 
        iprot.skip(ftype)
16774 
      iprot.readFieldEnd()
16775 
    iprot.readStructEnd()
16776 
 
16777 
  def write(self, oprot):
16778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16780 
      return
16781 
    oprot.writeStructBegin('reconcileCodCollection_result')
16782 
    if self.success is not None:
16783 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16784 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4910 phani.kuma 16785 
      for kiter342,viter343 in self.success.items():
16786 
        oprot.writeString(kiter342)
16787 
        oprot.writeString(viter343)
3956 chandransh 16788 
      oprot.writeMapEnd()
16789 
      oprot.writeFieldEnd()
16790 
    if self.ex is not None:
16791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16792 
      self.ex.write(oprot)
16793 
      oprot.writeFieldEnd()
16794 
    oprot.writeFieldStop()
16795 
    oprot.writeStructEnd()
16796 
 
16797 
  def validate(self):
16798 
    return
16799 
 
16800 
 
16801 
  def __repr__(self):
16802 
    L = ['%s=%r' % (key, value)
16803 
      for key, value in self.__dict__.iteritems()]
16804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16805 
 
16806 
  def __eq__(self, other):
16807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16808 
 
16809 
  def __ne__(self, other):
16810 
    return not (self == other)
4008 mandeep.dh 16811 
 
16812 
class getTransactionsRequiringExtraProcessing_args:
16813 
  """
16814 
  Attributes:
16815 
   - category
16816 
  """
16817 
 
16818 
  thrift_spec = (
16819 
    None, # 0
16820 
    (1, TType.I32, 'category', None, None, ), # 1
16821 
  )
16822 
 
16823 
  def __init__(self, category=None,):
16824 
    self.category = category
16825 
 
16826 
  def read(self, iprot):
16827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16829 
      return
16830 
    iprot.readStructBegin()
16831 
    while True:
16832 
      (fname, ftype, fid) = iprot.readFieldBegin()
16833 
      if ftype == TType.STOP:
16834 
        break
16835 
      if fid == 1:
16836 
        if ftype == TType.I32:
16837 
          self.category = iprot.readI32();
16838 
        else:
16839 
          iprot.skip(ftype)
16840 
      else:
16841 
        iprot.skip(ftype)
16842 
      iprot.readFieldEnd()
16843 
    iprot.readStructEnd()
16844 
 
16845 
  def write(self, oprot):
16846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16848 
      return
16849 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
16850 
    if self.category is not None:
16851 
      oprot.writeFieldBegin('category', TType.I32, 1)
16852 
      oprot.writeI32(self.category)
16853 
      oprot.writeFieldEnd()
16854 
    oprot.writeFieldStop()
16855 
    oprot.writeStructEnd()
16856 
 
16857 
  def validate(self):
16858 
    return
16859 
 
16860 
 
16861 
  def __repr__(self):
16862 
    L = ['%s=%r' % (key, value)
16863 
      for key, value in self.__dict__.iteritems()]
16864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16865 
 
16866 
  def __eq__(self, other):
16867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16868 
 
16869 
  def __ne__(self, other):
16870 
    return not (self == other)
16871 
 
16872 
class getTransactionsRequiringExtraProcessing_result:
16873 
  """
16874 
  Attributes:
16875 
   - success
16876 
  """
16877 
 
16878 
  thrift_spec = (
16879 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16880 
  )
16881 
 
16882 
  def __init__(self, success=None,):
16883 
    self.success = success
16884 
 
16885 
  def read(self, iprot):
16886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16888 
      return
16889 
    iprot.readStructBegin()
16890 
    while True:
16891 
      (fname, ftype, fid) = iprot.readFieldBegin()
16892 
      if ftype == TType.STOP:
16893 
        break
16894 
      if fid == 0:
16895 
        if ftype == TType.LIST:
16896 
          self.success = []
4910 phani.kuma 16897 
          (_etype347, _size344) = iprot.readListBegin()
16898 
          for _i348 in xrange(_size344):
16899 
            _elem349 = iprot.readI64();
16900 
            self.success.append(_elem349)
4008 mandeep.dh 16901 
          iprot.readListEnd()
16902 
        else:
16903 
          iprot.skip(ftype)
16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
16913 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
16914 
    if self.success is not None:
16915 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16916 
      oprot.writeListBegin(TType.I64, len(self.success))
4910 phani.kuma 16917 
      for iter350 in self.success:
16918 
        oprot.writeI64(iter350)
4008 mandeep.dh 16919 
      oprot.writeListEnd()
16920 
      oprot.writeFieldEnd()
16921 
    oprot.writeFieldStop()
16922 
    oprot.writeStructEnd()
16923 
 
16924 
  def validate(self):
16925 
    return
16926 
 
16927 
 
16928 
  def __repr__(self):
16929 
    L = ['%s=%r' % (key, value)
16930 
      for key, value in self.__dict__.iteritems()]
16931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16932 
 
16933 
  def __eq__(self, other):
16934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16935 
 
16936 
  def __ne__(self, other):
16937 
    return not (self == other)
16938 
 
16939 
class markTransactionAsProcessed_args:
16940 
  """
16941 
  Attributes:
16942 
   - transactionId
16943 
   - category
16944 
  """
16945 
 
16946 
  thrift_spec = (
16947 
    None, # 0
16948 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16949 
    (2, TType.I32, 'category', None, None, ), # 2
16950 
  )
16951 
 
16952 
  def __init__(self, transactionId=None, category=None,):
16953 
    self.transactionId = transactionId
16954 
    self.category = category
16955 
 
16956 
  def read(self, iprot):
16957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16959 
      return
16960 
    iprot.readStructBegin()
16961 
    while True:
16962 
      (fname, ftype, fid) = iprot.readFieldBegin()
16963 
      if ftype == TType.STOP:
16964 
        break
16965 
      if fid == 1:
16966 
        if ftype == TType.I64:
16967 
          self.transactionId = iprot.readI64();
16968 
        else:
16969 
          iprot.skip(ftype)
16970 
      elif fid == 2:
16971 
        if ftype == TType.I32:
16972 
          self.category = iprot.readI32();
16973 
        else:
16974 
          iprot.skip(ftype)
16975 
      else:
16976 
        iprot.skip(ftype)
16977 
      iprot.readFieldEnd()
16978 
    iprot.readStructEnd()
16979 
 
16980 
  def write(self, oprot):
16981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16983 
      return
16984 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
16985 
    if self.transactionId is not None:
16986 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16987 
      oprot.writeI64(self.transactionId)
16988 
      oprot.writeFieldEnd()
16989 
    if self.category is not None:
16990 
      oprot.writeFieldBegin('category', TType.I32, 2)
16991 
      oprot.writeI32(self.category)
16992 
      oprot.writeFieldEnd()
16993 
    oprot.writeFieldStop()
16994 
    oprot.writeStructEnd()
16995 
 
16996 
  def validate(self):
16997 
    return
16998 
 
16999 
 
17000 
  def __repr__(self):
17001 
    L = ['%s=%r' % (key, value)
17002 
      for key, value in self.__dict__.iteritems()]
17003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17004 
 
17005 
  def __eq__(self, other):
17006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17007 
 
17008 
  def __ne__(self, other):
17009 
    return not (self == other)
17010 
 
17011 
class markTransactionAsProcessed_result:
17012 
 
17013 
  thrift_spec = (
17014 
  )
17015 
 
17016 
  def read(self, iprot):
17017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17019 
      return
17020 
    iprot.readStructBegin()
17021 
    while True:
17022 
      (fname, ftype, fid) = iprot.readFieldBegin()
17023 
      if ftype == TType.STOP:
17024 
        break
17025 
      else:
17026 
        iprot.skip(ftype)
17027 
      iprot.readFieldEnd()
17028 
    iprot.readStructEnd()
17029 
 
17030 
  def write(self, oprot):
17031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17033 
      return
17034 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17035 
    oprot.writeFieldStop()
17036 
    oprot.writeStructEnd()
17037 
 
17038 
  def validate(self):
17039 
    return
17040 
 
17041 
 
17042 
  def __repr__(self):
17043 
    L = ['%s=%r' % (key, value)
17044 
      for key, value in self.__dict__.iteritems()]
17045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17046 
 
17047 
  def __eq__(self, other):
17048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17049 
 
17050 
  def __ne__(self, other):
17051 
    return not (self == other)
4018 chandransh 17052 
 
17053 
class getItemWiseRiskyOrdersCount_args:
17054 
 
17055 
  thrift_spec = (
17056 
  )
17057 
 
17058 
  def read(self, iprot):
17059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17061 
      return
17062 
    iprot.readStructBegin()
17063 
    while True:
17064 
      (fname, ftype, fid) = iprot.readFieldBegin()
17065 
      if ftype == TType.STOP:
17066 
        break
17067 
      else:
17068 
        iprot.skip(ftype)
17069 
      iprot.readFieldEnd()
17070 
    iprot.readStructEnd()
17071 
 
17072 
  def write(self, oprot):
17073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17075 
      return
17076 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17077 
    oprot.writeFieldStop()
17078 
    oprot.writeStructEnd()
17079 
 
17080 
  def validate(self):
17081 
    return
17082 
 
17083 
 
17084 
  def __repr__(self):
17085 
    L = ['%s=%r' % (key, value)
17086 
      for key, value in self.__dict__.iteritems()]
17087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17088 
 
17089 
  def __eq__(self, other):
17090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17091 
 
17092 
  def __ne__(self, other):
17093 
    return not (self == other)
17094 
 
17095 
class getItemWiseRiskyOrdersCount_result:
17096 
  """
17097 
  Attributes:
17098 
   - success
17099 
  """
17100 
 
17101 
  thrift_spec = (
17102 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17103 
  )
17104 
 
17105 
  def __init__(self, success=None,):
17106 
    self.success = success
17107 
 
17108 
  def read(self, iprot):
17109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17111 
      return
17112 
    iprot.readStructBegin()
17113 
    while True:
17114 
      (fname, ftype, fid) = iprot.readFieldBegin()
17115 
      if ftype == TType.STOP:
17116 
        break
17117 
      if fid == 0:
17118 
        if ftype == TType.MAP:
17119 
          self.success = {}
4910 phani.kuma 17120 
          (_ktype352, _vtype353, _size351 ) = iprot.readMapBegin()
17121 
          for _i355 in xrange(_size351):
17122 
            _key356 = iprot.readI64();
17123 
            _val357 = iprot.readI64();
17124 
            self.success[_key356] = _val357
4018 chandransh 17125 
          iprot.readMapEnd()
17126 
        else:
17127 
          iprot.skip(ftype)
17128 
      else:
17129 
        iprot.skip(ftype)
17130 
      iprot.readFieldEnd()
17131 
    iprot.readStructEnd()
17132 
 
17133 
  def write(self, oprot):
17134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17136 
      return
17137 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17138 
    if self.success is not None:
17139 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17140 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4910 phani.kuma 17141 
      for kiter358,viter359 in self.success.items():
17142 
        oprot.writeI64(kiter358)
17143 
        oprot.writeI64(viter359)
4018 chandransh 17144 
      oprot.writeMapEnd()
17145 
      oprot.writeFieldEnd()
17146 
    oprot.writeFieldStop()
17147 
    oprot.writeStructEnd()
17148 
 
17149 
  def validate(self):
17150 
    return
17151 
 
17152 
 
17153 
  def __repr__(self):
17154 
    L = ['%s=%r' % (key, value)
17155 
      for key, value in self.__dict__.iteritems()]
17156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17157 
 
17158 
  def __eq__(self, other):
17159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17160 
 
17161 
  def __ne__(self, other):
17162 
    return not (self == other)
4247 rajveer 17163 
 
4295 varun.gupt 17164 
class getOrdersForItemIds_args:
17165 
  """
17166 
  Attributes:
17167 
   - itemIds
17168 
  """
17169 
 
17170 
  thrift_spec = (
17171 
    None, # 0
17172 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17173 
  )
17174 
 
17175 
  def __init__(self, itemIds=None,):
17176 
    self.itemIds = itemIds
17177 
 
17178 
  def read(self, iprot):
17179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17181 
      return
17182 
    iprot.readStructBegin()
17183 
    while True:
17184 
      (fname, ftype, fid) = iprot.readFieldBegin()
17185 
      if ftype == TType.STOP:
17186 
        break
17187 
      if fid == 1:
17188 
        if ftype == TType.LIST:
17189 
          self.itemIds = []
4910 phani.kuma 17190 
          (_etype363, _size360) = iprot.readListBegin()
17191 
          for _i364 in xrange(_size360):
17192 
            _elem365 = iprot.readI64();
17193 
            self.itemIds.append(_elem365)
4295 varun.gupt 17194 
          iprot.readListEnd()
17195 
        else:
17196 
          iprot.skip(ftype)
17197 
      else:
17198 
        iprot.skip(ftype)
17199 
      iprot.readFieldEnd()
17200 
    iprot.readStructEnd()
17201 
 
17202 
  def write(self, oprot):
17203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17205 
      return
17206 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17207 
    if self.itemIds is not None:
17208 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17209 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4910 phani.kuma 17210 
      for iter366 in self.itemIds:
17211 
        oprot.writeI64(iter366)
4295 varun.gupt 17212 
      oprot.writeListEnd()
17213 
      oprot.writeFieldEnd()
17214 
    oprot.writeFieldStop()
17215 
    oprot.writeStructEnd()
17216 
 
17217 
  def validate(self):
17218 
    return
17219 
 
17220 
 
17221 
  def __repr__(self):
17222 
    L = ['%s=%r' % (key, value)
17223 
      for key, value in self.__dict__.iteritems()]
17224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17225 
 
17226 
  def __eq__(self, other):
17227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17228 
 
17229 
  def __ne__(self, other):
17230 
    return not (self == other)
17231 
 
17232 
class getOrdersForItemIds_result:
17233 
  """
17234 
  Attributes:
17235 
   - success
17236 
  """
17237 
 
17238 
  thrift_spec = (
17239 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17240 
  )
17241 
 
17242 
  def __init__(self, success=None,):
17243 
    self.success = success
17244 
 
17245 
  def read(self, iprot):
17246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17248 
      return
17249 
    iprot.readStructBegin()
17250 
    while True:
17251 
      (fname, ftype, fid) = iprot.readFieldBegin()
17252 
      if ftype == TType.STOP:
17253 
        break
17254 
      if fid == 0:
17255 
        if ftype == TType.LIST:
17256 
          self.success = []
4910 phani.kuma 17257 
          (_etype370, _size367) = iprot.readListBegin()
17258 
          for _i371 in xrange(_size367):
17259 
            _elem372 = Order()
17260 
            _elem372.read(iprot)
17261 
            self.success.append(_elem372)
4295 varun.gupt 17262 
          iprot.readListEnd()
17263 
        else:
17264 
          iprot.skip(ftype)
17265 
      else:
17266 
        iprot.skip(ftype)
17267 
      iprot.readFieldEnd()
17268 
    iprot.readStructEnd()
17269 
 
17270 
  def write(self, oprot):
17271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17273 
      return
17274 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17275 
    if self.success is not None:
17276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 17278 
      for iter373 in self.success:
17279 
        iter373.write(oprot)
4295 varun.gupt 17280 
      oprot.writeListEnd()
17281 
      oprot.writeFieldEnd()
17282 
    oprot.writeFieldStop()
17283 
    oprot.writeStructEnd()
17284 
 
17285 
  def validate(self):
17286 
    return
17287 
 
17288 
 
17289 
  def __repr__(self):
17290 
    L = ['%s=%r' % (key, value)
17291 
      for key, value in self.__dict__.iteritems()]
17292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17293 
 
17294 
  def __eq__(self, other):
17295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17296 
 
17297 
  def __ne__(self, other):
17298 
    return not (self == other)
17299 
 
4247 rajveer 17300 
class markOrderCancellationRequestReceived_args:
17301 
  """
17302 
  Attributes:
17303 
   - orderId
17304 
  """
17305 
 
17306 
  thrift_spec = (
17307 
    None, # 0
17308 
    (1, TType.I64, 'orderId', None, None, ), # 1
17309 
  )
17310 
 
17311 
  def __init__(self, orderId=None,):
17312 
    self.orderId = orderId
17313 
 
17314 
  def read(self, iprot):
17315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17317 
      return
17318 
    iprot.readStructBegin()
17319 
    while True:
17320 
      (fname, ftype, fid) = iprot.readFieldBegin()
17321 
      if ftype == TType.STOP:
17322 
        break
17323 
      if fid == 1:
17324 
        if ftype == TType.I64:
17325 
          self.orderId = iprot.readI64();
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      else:
17329 
        iprot.skip(ftype)
17330 
      iprot.readFieldEnd()
17331 
    iprot.readStructEnd()
17332 
 
17333 
  def write(self, oprot):
17334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17336 
      return
17337 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17338 
    if self.orderId is not None:
17339 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17340 
      oprot.writeI64(self.orderId)
17341 
      oprot.writeFieldEnd()
17342 
    oprot.writeFieldStop()
17343 
    oprot.writeStructEnd()
17344 
 
17345 
  def validate(self):
17346 
    return
17347 
 
17348 
 
17349 
  def __repr__(self):
17350 
    L = ['%s=%r' % (key, value)
17351 
      for key, value in self.__dict__.iteritems()]
17352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17353 
 
17354 
  def __eq__(self, other):
17355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17356 
 
17357 
  def __ne__(self, other):
17358 
    return not (self == other)
17359 
 
17360 
class markOrderCancellationRequestReceived_result:
17361 
  """
17362 
  Attributes:
17363 
   - ex
17364 
  """
17365 
 
17366 
  thrift_spec = (
17367 
    None, # 0
17368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17369 
  )
17370 
 
17371 
  def __init__(self, ex=None,):
17372 
    self.ex = ex
17373 
 
17374 
  def read(self, iprot):
17375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17377 
      return
17378 
    iprot.readStructBegin()
17379 
    while True:
17380 
      (fname, ftype, fid) = iprot.readFieldBegin()
17381 
      if ftype == TType.STOP:
17382 
        break
17383 
      if fid == 1:
17384 
        if ftype == TType.STRUCT:
17385 
          self.ex = TransactionServiceException()
17386 
          self.ex.read(iprot)
17387 
        else:
17388 
          iprot.skip(ftype)
17389 
      else:
17390 
        iprot.skip(ftype)
17391 
      iprot.readFieldEnd()
17392 
    iprot.readStructEnd()
17393 
 
17394 
  def write(self, oprot):
17395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17397 
      return
17398 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17399 
    if self.ex is not None:
17400 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17401 
      self.ex.write(oprot)
17402 
      oprot.writeFieldEnd()
17403 
    oprot.writeFieldStop()
17404 
    oprot.writeStructEnd()
17405 
 
17406 
  def validate(self):
17407 
    return
17408 
 
17409 
 
17410 
  def __repr__(self):
17411 
    L = ['%s=%r' % (key, value)
17412 
      for key, value in self.__dict__.iteritems()]
17413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17414 
 
17415 
  def __eq__(self, other):
17416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17417 
 
17418 
  def __ne__(self, other):
17419 
    return not (self == other)
17420 
 
17421 
class markOrderCancellationRequestConfirmed_args:
17422 
  """
17423 
  Attributes:
17424 
   - orderId
17425 
  """
17426 
 
17427 
  thrift_spec = (
17428 
    None, # 0
17429 
    (1, TType.I64, 'orderId', None, None, ), # 1
17430 
  )
17431 
 
17432 
  def __init__(self, orderId=None,):
17433 
    self.orderId = orderId
17434 
 
17435 
  def read(self, iprot):
17436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17438 
      return
17439 
    iprot.readStructBegin()
17440 
    while True:
17441 
      (fname, ftype, fid) = iprot.readFieldBegin()
17442 
      if ftype == TType.STOP:
17443 
        break
17444 
      if fid == 1:
17445 
        if ftype == TType.I64:
17446 
          self.orderId = iprot.readI64();
17447 
        else:
17448 
          iprot.skip(ftype)
17449 
      else:
17450 
        iprot.skip(ftype)
17451 
      iprot.readFieldEnd()
17452 
    iprot.readStructEnd()
17453 
 
17454 
  def write(self, oprot):
17455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17457 
      return
17458 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17459 
    if self.orderId is not None:
17460 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17461 
      oprot.writeI64(self.orderId)
17462 
      oprot.writeFieldEnd()
17463 
    oprot.writeFieldStop()
17464 
    oprot.writeStructEnd()
17465 
 
17466 
  def validate(self):
17467 
    return
17468 
 
17469 
 
17470 
  def __repr__(self):
17471 
    L = ['%s=%r' % (key, value)
17472 
      for key, value in self.__dict__.iteritems()]
17473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17474 
 
17475 
  def __eq__(self, other):
17476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17477 
 
17478 
  def __ne__(self, other):
17479 
    return not (self == other)
17480 
 
17481 
class markOrderCancellationRequestConfirmed_result:
17482 
  """
17483 
  Attributes:
17484 
   - ex
17485 
  """
17486 
 
17487 
  thrift_spec = (
17488 
    None, # 0
17489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17490 
  )
17491 
 
17492 
  def __init__(self, ex=None,):
17493 
    self.ex = ex
17494 
 
17495 
  def read(self, iprot):
17496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17498 
      return
17499 
    iprot.readStructBegin()
17500 
    while True:
17501 
      (fname, ftype, fid) = iprot.readFieldBegin()
17502 
      if ftype == TType.STOP:
17503 
        break
17504 
      if fid == 1:
17505 
        if ftype == TType.STRUCT:
17506 
          self.ex = TransactionServiceException()
17507 
          self.ex.read(iprot)
17508 
        else:
17509 
          iprot.skip(ftype)
17510 
      else:
17511 
        iprot.skip(ftype)
17512 
      iprot.readFieldEnd()
17513 
    iprot.readStructEnd()
17514 
 
17515 
  def write(self, oprot):
17516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17518 
      return
17519 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17520 
    if self.ex is not None:
17521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17522 
      self.ex.write(oprot)
17523 
      oprot.writeFieldEnd()
17524 
    oprot.writeFieldStop()
17525 
    oprot.writeStructEnd()
17526 
 
17527 
  def validate(self):
17528 
    return
17529 
 
17530 
 
17531 
  def __repr__(self):
17532 
    L = ['%s=%r' % (key, value)
17533 
      for key, value in self.__dict__.iteritems()]
17534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17535 
 
17536 
  def __eq__(self, other):
17537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17538 
 
17539 
  def __ne__(self, other):
17540 
    return not (self == other)
17541 
 
17542 
class markOrderCancellationRequestDenied_args:
17543 
  """
17544 
  Attributes:
17545 
   - orderId
17546 
  """
17547 
 
17548 
  thrift_spec = (
17549 
    None, # 0
17550 
    (1, TType.I64, 'orderId', None, None, ), # 1
17551 
  )
17552 
 
17553 
  def __init__(self, orderId=None,):
17554 
    self.orderId = orderId
17555 
 
17556 
  def read(self, iprot):
17557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17559 
      return
17560 
    iprot.readStructBegin()
17561 
    while True:
17562 
      (fname, ftype, fid) = iprot.readFieldBegin()
17563 
      if ftype == TType.STOP:
17564 
        break
17565 
      if fid == 1:
17566 
        if ftype == TType.I64:
17567 
          self.orderId = iprot.readI64();
17568 
        else:
17569 
          iprot.skip(ftype)
17570 
      else:
17571 
        iprot.skip(ftype)
17572 
      iprot.readFieldEnd()
17573 
    iprot.readStructEnd()
17574 
 
17575 
  def write(self, oprot):
17576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17578 
      return
17579 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17580 
    if self.orderId is not None:
17581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17582 
      oprot.writeI64(self.orderId)
17583 
      oprot.writeFieldEnd()
17584 
    oprot.writeFieldStop()
17585 
    oprot.writeStructEnd()
17586 
 
17587 
  def validate(self):
17588 
    return
17589 
 
17590 
 
17591 
  def __repr__(self):
17592 
    L = ['%s=%r' % (key, value)
17593 
      for key, value in self.__dict__.iteritems()]
17594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17595 
 
17596 
  def __eq__(self, other):
17597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17598 
 
17599 
  def __ne__(self, other):
17600 
    return not (self == other)
17601 
 
17602 
class markOrderCancellationRequestDenied_result:
17603 
  """
17604 
  Attributes:
17605 
   - ex
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    None, # 0
17610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17611 
  )
17612 
 
17613 
  def __init__(self, ex=None,):
17614 
    self.ex = ex
17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 1:
17626 
        if ftype == TType.STRUCT:
17627 
          self.ex = TransactionServiceException()
17628 
          self.ex.read(iprot)
17629 
        else:
17630 
          iprot.skip(ftype)
17631 
      else:
17632 
        iprot.skip(ftype)
17633 
      iprot.readFieldEnd()
17634 
    iprot.readStructEnd()
17635 
 
17636 
  def write(self, oprot):
17637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17639 
      return
17640 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17641 
    if self.ex is not None:
17642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17643 
      self.ex.write(oprot)
17644 
      oprot.writeFieldEnd()
17645 
    oprot.writeFieldStop()
17646 
    oprot.writeStructEnd()
17647 
 
17648 
  def validate(self):
17649 
    return
17650 
 
17651 
 
17652 
  def __repr__(self):
17653 
    L = ['%s=%r' % (key, value)
17654 
      for key, value in self.__dict__.iteritems()]
17655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17656 
 
17657 
  def __eq__(self, other):
17658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17659 
 
17660 
  def __ne__(self, other):
17661 
    return not (self == other)
17662 
 
4258 rajveer 17663 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 17664 
  """
17665 
  Attributes:
4258 rajveer 17666 
   - transactionId
4247 rajveer 17667 
  """
17668 
 
17669 
  thrift_spec = (
17670 
    None, # 0
4258 rajveer 17671 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 17672 
  )
17673 
 
4258 rajveer 17674 
  def __init__(self, transactionId=None,):
17675 
    self.transactionId = transactionId
4247 rajveer 17676 
 
17677 
  def read(self, iprot):
17678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17680 
      return
17681 
    iprot.readStructBegin()
17682 
    while True:
17683 
      (fname, ftype, fid) = iprot.readFieldBegin()
17684 
      if ftype == TType.STOP:
17685 
        break
17686 
      if fid == 1:
17687 
        if ftype == TType.I64:
4258 rajveer 17688 
          self.transactionId = iprot.readI64();
4247 rajveer 17689 
        else:
17690 
          iprot.skip(ftype)
17691 
      else:
17692 
        iprot.skip(ftype)
17693 
      iprot.readFieldEnd()
17694 
    iprot.readStructEnd()
17695 
 
17696 
  def write(self, oprot):
17697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17699 
      return
4258 rajveer 17700 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
17701 
    if self.transactionId is not None:
17702 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17703 
      oprot.writeI64(self.transactionId)
4247 rajveer 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 
 
4258 rajveer 17723 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 17724 
  """
17725 
  Attributes:
17726 
   - ex
17727 
  """
17728 
 
17729 
  thrift_spec = (
17730 
    None, # 0
17731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17732 
  )
17733 
 
17734 
  def __init__(self, ex=None,):
17735 
    self.ex = ex
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 1:
17747 
        if ftype == TType.STRUCT:
17748 
          self.ex = TransactionServiceException()
17749 
          self.ex.read(iprot)
17750 
        else:
17751 
          iprot.skip(ftype)
17752 
      else:
17753 
        iprot.skip(ftype)
17754 
      iprot.readFieldEnd()
17755 
    iprot.readStructEnd()
17756 
 
17757 
  def write(self, oprot):
17758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17760 
      return
4258 rajveer 17761 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 17762 
    if self.ex is not None:
17763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17764 
      self.ex.write(oprot)
17765 
      oprot.writeFieldEnd()
17766 
    oprot.writeFieldStop()
17767 
    oprot.writeStructEnd()
17768 
 
17769 
  def validate(self):
17770 
    return
17771 
 
17772 
 
17773 
  def __repr__(self):
17774 
    L = ['%s=%r' % (key, value)
17775 
      for key, value in self.__dict__.iteritems()]
17776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17777 
 
17778 
  def __eq__(self, other):
17779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17780 
 
17781 
  def __ne__(self, other):
17782 
    return not (self == other)
4259 anupam.sin 17783 
 
17784 
class refundTransaction_args:
17785 
  """
17786 
  Attributes:
17787 
   - transactionId
17788 
   - refundedBy
17789 
   - reason
17790 
  """
17791 
 
17792 
  thrift_spec = (
17793 
    None, # 0
17794 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17795 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17796 
    (3, TType.STRING, 'reason', None, None, ), # 3
17797 
  )
17798 
 
17799 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
17800 
    self.transactionId = transactionId
17801 
    self.refundedBy = refundedBy
17802 
    self.reason = reason
17803 
 
17804 
  def read(self, iprot):
17805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17807 
      return
17808 
    iprot.readStructBegin()
17809 
    while True:
17810 
      (fname, ftype, fid) = iprot.readFieldBegin()
17811 
      if ftype == TType.STOP:
17812 
        break
17813 
      if fid == 1:
17814 
        if ftype == TType.I64:
17815 
          self.transactionId = iprot.readI64();
17816 
        else:
17817 
          iprot.skip(ftype)
17818 
      elif fid == 2:
17819 
        if ftype == TType.STRING:
17820 
          self.refundedBy = iprot.readString();
17821 
        else:
17822 
          iprot.skip(ftype)
17823 
      elif fid == 3:
17824 
        if ftype == TType.STRING:
17825 
          self.reason = iprot.readString();
17826 
        else:
17827 
          iprot.skip(ftype)
17828 
      else:
17829 
        iprot.skip(ftype)
17830 
      iprot.readFieldEnd()
17831 
    iprot.readStructEnd()
17832 
 
17833 
  def write(self, oprot):
17834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17836 
      return
17837 
    oprot.writeStructBegin('refundTransaction_args')
17838 
    if self.transactionId is not None:
17839 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17840 
      oprot.writeI64(self.transactionId)
17841 
      oprot.writeFieldEnd()
17842 
    if self.refundedBy is not None:
17843 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17844 
      oprot.writeString(self.refundedBy)
17845 
      oprot.writeFieldEnd()
17846 
    if self.reason is not None:
17847 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17848 
      oprot.writeString(self.reason)
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 refundTransaction_result:
17869 
  """
17870 
  Attributes:
17871 
   - ex
17872 
  """
17873 
 
17874 
  thrift_spec = (
17875 
    None, # 0
17876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17877 
  )
17878 
 
17879 
  def __init__(self, ex=None,):
17880 
    self.ex = ex
17881 
 
17882 
  def read(self, iprot):
17883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17885 
      return
17886 
    iprot.readStructBegin()
17887 
    while True:
17888 
      (fname, ftype, fid) = iprot.readFieldBegin()
17889 
      if ftype == TType.STOP:
17890 
        break
17891 
      if fid == 1:
17892 
        if ftype == TType.STRUCT:
17893 
          self.ex = TransactionServiceException()
17894 
          self.ex.read(iprot)
17895 
        else:
17896 
          iprot.skip(ftype)
17897 
      else:
17898 
        iprot.skip(ftype)
17899 
      iprot.readFieldEnd()
17900 
    iprot.readStructEnd()
17901 
 
17902 
  def write(self, oprot):
17903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17905 
      return
17906 
    oprot.writeStructBegin('refundTransaction_result')
17907 
    if self.ex is not None:
17908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17909 
      self.ex.write(oprot)
17910 
      oprot.writeFieldEnd()
17911 
    oprot.writeFieldStop()
17912 
    oprot.writeStructEnd()
17913 
 
17914 
  def validate(self):
17915 
    return
17916 
 
17917 
 
17918 
  def __repr__(self):
17919 
    L = ['%s=%r' % (key, value)
17920 
      for key, value in self.__dict__.iteritems()]
17921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17922 
 
17923 
  def __eq__(self, other):
17924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17925 
 
17926 
  def __ne__(self, other):
17927 
    return not (self == other)
4285 rajveer 17928 
 
4324 mandeep.dh 17929 
class updateShipmentAddress_args:
17930 
  """
17931 
  Attributes:
17932 
   - orderId
17933 
   - addressId
17934 
  """
17935 
 
17936 
  thrift_spec = (
17937 
    None, # 0
17938 
    (1, TType.I64, 'orderId', None, None, ), # 1
17939 
    (2, TType.I64, 'addressId', None, None, ), # 2
17940 
  )
17941 
 
17942 
  def __init__(self, orderId=None, addressId=None,):
17943 
    self.orderId = orderId
17944 
    self.addressId = addressId
17945 
 
17946 
  def read(self, iprot):
17947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17949 
      return
17950 
    iprot.readStructBegin()
17951 
    while True:
17952 
      (fname, ftype, fid) = iprot.readFieldBegin()
17953 
      if ftype == TType.STOP:
17954 
        break
17955 
      if fid == 1:
17956 
        if ftype == TType.I64:
17957 
          self.orderId = iprot.readI64();
17958 
        else:
17959 
          iprot.skip(ftype)
17960 
      elif fid == 2:
17961 
        if ftype == TType.I64:
17962 
          self.addressId = iprot.readI64();
17963 
        else:
17964 
          iprot.skip(ftype)
17965 
      else:
17966 
        iprot.skip(ftype)
17967 
      iprot.readFieldEnd()
17968 
    iprot.readStructEnd()
17969 
 
17970 
  def write(self, oprot):
17971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17973 
      return
17974 
    oprot.writeStructBegin('updateShipmentAddress_args')
17975 
    if self.orderId is not None:
17976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17977 
      oprot.writeI64(self.orderId)
17978 
      oprot.writeFieldEnd()
17979 
    if self.addressId is not None:
17980 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
17981 
      oprot.writeI64(self.addressId)
17982 
      oprot.writeFieldEnd()
17983 
    oprot.writeFieldStop()
17984 
    oprot.writeStructEnd()
17985 
 
17986 
  def validate(self):
17987 
    return
17988 
 
17989 
 
17990 
  def __repr__(self):
17991 
    L = ['%s=%r' % (key, value)
17992 
      for key, value in self.__dict__.iteritems()]
17993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17994 
 
17995 
  def __eq__(self, other):
17996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17997 
 
17998 
  def __ne__(self, other):
17999 
    return not (self == other)
18000 
 
18001 
class updateShipmentAddress_result:
18002 
  """
18003 
  Attributes:
18004 
   - ex
18005 
  """
18006 
 
18007 
  thrift_spec = (
18008 
    None, # 0
18009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18010 
  )
18011 
 
18012 
  def __init__(self, ex=None,):
18013 
    self.ex = ex
18014 
 
18015 
  def read(self, iprot):
18016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18018 
      return
18019 
    iprot.readStructBegin()
18020 
    while True:
18021 
      (fname, ftype, fid) = iprot.readFieldBegin()
18022 
      if ftype == TType.STOP:
18023 
        break
18024 
      if fid == 1:
18025 
        if ftype == TType.STRUCT:
18026 
          self.ex = TransactionServiceException()
18027 
          self.ex.read(iprot)
18028 
        else:
18029 
          iprot.skip(ftype)
18030 
      else:
18031 
        iprot.skip(ftype)
18032 
      iprot.readFieldEnd()
18033 
    iprot.readStructEnd()
18034 
 
18035 
  def write(self, oprot):
18036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18038 
      return
18039 
    oprot.writeStructBegin('updateShipmentAddress_result')
18040 
    if self.ex is not None:
18041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18042 
      self.ex.write(oprot)
18043 
      oprot.writeFieldEnd()
18044 
    oprot.writeFieldStop()
18045 
    oprot.writeStructEnd()
18046 
 
18047 
  def validate(self):
18048 
    return
18049 
 
18050 
 
18051 
  def __repr__(self):
18052 
    L = ['%s=%r' % (key, value)
18053 
      for key, value in self.__dict__.iteritems()]
18054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18055 
 
18056 
  def __eq__(self, other):
18057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18058 
 
18059 
  def __ne__(self, other):
18060 
    return not (self == other)
18061 
 
4285 rajveer 18062 
class acceptOrdersForItemId_args:
18063 
  """
18064 
  Attributes:
18065 
   - itemId
18066 
   - inventory
18067 
  """
18068 
 
18069 
  thrift_spec = (
18070 
    None, # 0
18071 
    (1, TType.I64, 'itemId', None, None, ), # 1
18072 
    (2, TType.I64, 'inventory', None, None, ), # 2
18073 
  )
18074 
 
18075 
  def __init__(self, itemId=None, inventory=None,):
18076 
    self.itemId = itemId
18077 
    self.inventory = inventory
18078 
 
18079 
  def read(self, iprot):
18080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18082 
      return
18083 
    iprot.readStructBegin()
18084 
    while True:
18085 
      (fname, ftype, fid) = iprot.readFieldBegin()
18086 
      if ftype == TType.STOP:
18087 
        break
18088 
      if fid == 1:
18089 
        if ftype == TType.I64:
18090 
          self.itemId = iprot.readI64();
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      elif fid == 2:
18094 
        if ftype == TType.I64:
18095 
          self.inventory = iprot.readI64();
18096 
        else:
18097 
          iprot.skip(ftype)
18098 
      else:
18099 
        iprot.skip(ftype)
18100 
      iprot.readFieldEnd()
18101 
    iprot.readStructEnd()
18102 
 
18103 
  def write(self, oprot):
18104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18106 
      return
18107 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18108 
    if self.itemId is not None:
18109 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18110 
      oprot.writeI64(self.itemId)
18111 
      oprot.writeFieldEnd()
18112 
    if self.inventory is not None:
18113 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18114 
      oprot.writeI64(self.inventory)
18115 
      oprot.writeFieldEnd()
18116 
    oprot.writeFieldStop()
18117 
    oprot.writeStructEnd()
18118 
 
18119 
  def validate(self):
18120 
    return
18121 
 
18122 
 
18123 
  def __repr__(self):
18124 
    L = ['%s=%r' % (key, value)
18125 
      for key, value in self.__dict__.iteritems()]
18126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18127 
 
18128 
  def __eq__(self, other):
18129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18130 
 
18131 
  def __ne__(self, other):
18132 
    return not (self == other)
18133 
 
18134 
class acceptOrdersForItemId_result:
18135 
  """
18136 
  Attributes:
18137 
   - success
18138 
   - ex
18139 
  """
18140 
 
18141 
  thrift_spec = (
18142 
    (0, TType.BOOL, 'success', None, None, ), # 0
18143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18144 
  )
18145 
 
18146 
  def __init__(self, success=None, ex=None,):
18147 
    self.success = success
18148 
    self.ex = ex
18149 
 
18150 
  def read(self, iprot):
18151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18153 
      return
18154 
    iprot.readStructBegin()
18155 
    while True:
18156 
      (fname, ftype, fid) = iprot.readFieldBegin()
18157 
      if ftype == TType.STOP:
18158 
        break
18159 
      if fid == 0:
18160 
        if ftype == TType.BOOL:
18161 
          self.success = iprot.readBool();
18162 
        else:
18163 
          iprot.skip(ftype)
18164 
      elif fid == 1:
18165 
        if ftype == TType.STRUCT:
18166 
          self.ex = TransactionServiceException()
18167 
          self.ex.read(iprot)
18168 
        else:
18169 
          iprot.skip(ftype)
18170 
      else:
18171 
        iprot.skip(ftype)
18172 
      iprot.readFieldEnd()
18173 
    iprot.readStructEnd()
18174 
 
18175 
  def write(self, oprot):
18176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18178 
      return
18179 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18180 
    if self.success is not None:
18181 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18182 
      oprot.writeBool(self.success)
18183 
      oprot.writeFieldEnd()
18184 
    if self.ex is not None:
18185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18186 
      self.ex.write(oprot)
18187 
      oprot.writeFieldEnd()
18188 
    oprot.writeFieldStop()
18189 
    oprot.writeStructEnd()
18190 
 
18191 
  def validate(self):
18192 
    return
18193 
 
18194 
 
18195 
  def __repr__(self):
18196 
    L = ['%s=%r' % (key, value)
18197 
      for key, value in self.__dict__.iteritems()]
18198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18199 
 
18200 
  def __eq__(self, other):
18201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18202 
 
18203 
  def __ne__(self, other):
18204 
    return not (self == other)
4303 rajveer 18205 
 
18206 
class markOrdersAsPORaised_args:
18207 
  """
18208 
  Attributes:
18209 
   - vendorId
18210 
   - itemId
18211 
   - quantity
18212 
   - estimate
4369 rajveer 18213 
   - isReminder
4303 rajveer 18214 
  """
18215 
 
18216 
  thrift_spec = (
18217 
    None, # 0
18218 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18219 
    (2, TType.I64, 'itemId', None, None, ), # 2
18220 
    (3, TType.I64, 'quantity', None, None, ), # 3
18221 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18222 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18223 
  )
18224 
 
4369 rajveer 18225 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18226 
    self.vendorId = vendorId
18227 
    self.itemId = itemId
18228 
    self.quantity = quantity
18229 
    self.estimate = estimate
4369 rajveer 18230 
    self.isReminder = isReminder
4303 rajveer 18231 
 
18232 
  def read(self, iprot):
18233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18235 
      return
18236 
    iprot.readStructBegin()
18237 
    while True:
18238 
      (fname, ftype, fid) = iprot.readFieldBegin()
18239 
      if ftype == TType.STOP:
18240 
        break
18241 
      if fid == 1:
18242 
        if ftype == TType.I64:
18243 
          self.vendorId = iprot.readI64();
18244 
        else:
18245 
          iprot.skip(ftype)
18246 
      elif fid == 2:
18247 
        if ftype == TType.I64:
18248 
          self.itemId = iprot.readI64();
18249 
        else:
18250 
          iprot.skip(ftype)
18251 
      elif fid == 3:
18252 
        if ftype == TType.I64:
18253 
          self.quantity = iprot.readI64();
18254 
        else:
18255 
          iprot.skip(ftype)
18256 
      elif fid == 4:
18257 
        if ftype == TType.I64:
18258 
          self.estimate = iprot.readI64();
18259 
        else:
18260 
          iprot.skip(ftype)
4369 rajveer 18261 
      elif fid == 5:
18262 
        if ftype == TType.BOOL:
18263 
          self.isReminder = iprot.readBool();
18264 
        else:
18265 
          iprot.skip(ftype)
4303 rajveer 18266 
      else:
18267 
        iprot.skip(ftype)
18268 
      iprot.readFieldEnd()
18269 
    iprot.readStructEnd()
18270 
 
18271 
  def write(self, oprot):
18272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18274 
      return
18275 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18276 
    if self.vendorId is not None:
18277 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18278 
      oprot.writeI64(self.vendorId)
18279 
      oprot.writeFieldEnd()
18280 
    if self.itemId is not None:
18281 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18282 
      oprot.writeI64(self.itemId)
18283 
      oprot.writeFieldEnd()
18284 
    if self.quantity is not None:
18285 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18286 
      oprot.writeI64(self.quantity)
18287 
      oprot.writeFieldEnd()
18288 
    if self.estimate is not None:
18289 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18290 
      oprot.writeI64(self.estimate)
18291 
      oprot.writeFieldEnd()
4369 rajveer 18292 
    if self.isReminder is not None:
18293 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18294 
      oprot.writeBool(self.isReminder)
18295 
      oprot.writeFieldEnd()
4303 rajveer 18296 
    oprot.writeFieldStop()
18297 
    oprot.writeStructEnd()
18298 
 
18299 
  def validate(self):
18300 
    return
18301 
 
18302 
 
18303 
  def __repr__(self):
18304 
    L = ['%s=%r' % (key, value)
18305 
      for key, value in self.__dict__.iteritems()]
18306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18307 
 
18308 
  def __eq__(self, other):
18309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18310 
 
18311 
  def __ne__(self, other):
18312 
    return not (self == other)
18313 
 
18314 
class markOrdersAsPORaised_result:
18315 
  """
18316 
  Attributes:
18317 
   - ex
18318 
  """
18319 
 
18320 
  thrift_spec = (
18321 
    None, # 0
18322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18323 
  )
18324 
 
18325 
  def __init__(self, ex=None,):
18326 
    self.ex = ex
18327 
 
18328 
  def read(self, iprot):
18329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18331 
      return
18332 
    iprot.readStructBegin()
18333 
    while True:
18334 
      (fname, ftype, fid) = iprot.readFieldBegin()
18335 
      if ftype == TType.STOP:
18336 
        break
18337 
      if fid == 1:
18338 
        if ftype == TType.STRUCT:
18339 
          self.ex = TransactionServiceException()
18340 
          self.ex.read(iprot)
18341 
        else:
18342 
          iprot.skip(ftype)
18343 
      else:
18344 
        iprot.skip(ftype)
18345 
      iprot.readFieldEnd()
18346 
    iprot.readStructEnd()
18347 
 
18348 
  def write(self, oprot):
18349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18351 
      return
18352 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18353 
    if self.ex is not None:
18354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18355 
      self.ex.write(oprot)
18356 
      oprot.writeFieldEnd()
18357 
    oprot.writeFieldStop()
18358 
    oprot.writeStructEnd()
18359 
 
18360 
  def validate(self):
18361 
    return
18362 
 
18363 
 
18364 
  def __repr__(self):
18365 
    L = ['%s=%r' % (key, value)
18366 
      for key, value in self.__dict__.iteritems()]
18367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18368 
 
18369 
  def __eq__(self, other):
18370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18371 
 
18372 
  def __ne__(self, other):
18373 
    return not (self == other)
18374 
 
18375 
class markOrdersAsReversalInitiated_args:
18376 
  """
18377 
  Attributes:
18378 
   - vendorId
18379 
   - itemId
18380 
   - quantity
18381 
   - estimate
4369 rajveer 18382 
   - isReminder
4303 rajveer 18383 
  """
18384 
 
18385 
  thrift_spec = (
18386 
    None, # 0
18387 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18388 
    (2, TType.I64, 'itemId', None, None, ), # 2
18389 
    (3, TType.I64, 'quantity', None, None, ), # 3
18390 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18391 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18392 
  )
18393 
 
4369 rajveer 18394 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18395 
    self.vendorId = vendorId
18396 
    self.itemId = itemId
18397 
    self.quantity = quantity
18398 
    self.estimate = estimate
4369 rajveer 18399 
    self.isReminder = isReminder
4303 rajveer 18400 
 
18401 
  def read(self, iprot):
18402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18404 
      return
18405 
    iprot.readStructBegin()
18406 
    while True:
18407 
      (fname, ftype, fid) = iprot.readFieldBegin()
18408 
      if ftype == TType.STOP:
18409 
        break
18410 
      if fid == 1:
18411 
        if ftype == TType.I64:
18412 
          self.vendorId = iprot.readI64();
18413 
        else:
18414 
          iprot.skip(ftype)
18415 
      elif fid == 2:
18416 
        if ftype == TType.I64:
18417 
          self.itemId = iprot.readI64();
18418 
        else:
18419 
          iprot.skip(ftype)
18420 
      elif fid == 3:
18421 
        if ftype == TType.I64:
18422 
          self.quantity = iprot.readI64();
18423 
        else:
18424 
          iprot.skip(ftype)
18425 
      elif fid == 4:
18426 
        if ftype == TType.I64:
18427 
          self.estimate = iprot.readI64();
18428 
        else:
18429 
          iprot.skip(ftype)
4369 rajveer 18430 
      elif fid == 5:
18431 
        if ftype == TType.BOOL:
18432 
          self.isReminder = iprot.readBool();
18433 
        else:
18434 
          iprot.skip(ftype)
4303 rajveer 18435 
      else:
18436 
        iprot.skip(ftype)
18437 
      iprot.readFieldEnd()
18438 
    iprot.readStructEnd()
18439 
 
18440 
  def write(self, oprot):
18441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18443 
      return
18444 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18445 
    if self.vendorId is not None:
18446 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18447 
      oprot.writeI64(self.vendorId)
18448 
      oprot.writeFieldEnd()
18449 
    if self.itemId is not None:
18450 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18451 
      oprot.writeI64(self.itemId)
18452 
      oprot.writeFieldEnd()
18453 
    if self.quantity is not None:
18454 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18455 
      oprot.writeI64(self.quantity)
18456 
      oprot.writeFieldEnd()
18457 
    if self.estimate is not None:
18458 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18459 
      oprot.writeI64(self.estimate)
18460 
      oprot.writeFieldEnd()
4369 rajveer 18461 
    if self.isReminder is not None:
18462 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18463 
      oprot.writeBool(self.isReminder)
18464 
      oprot.writeFieldEnd()
4303 rajveer 18465 
    oprot.writeFieldStop()
18466 
    oprot.writeStructEnd()
18467 
 
18468 
  def validate(self):
18469 
    return
18470 
 
18471 
 
18472 
  def __repr__(self):
18473 
    L = ['%s=%r' % (key, value)
18474 
      for key, value in self.__dict__.iteritems()]
18475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18476 
 
18477 
  def __eq__(self, other):
18478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18479 
 
18480 
  def __ne__(self, other):
18481 
    return not (self == other)
18482 
 
18483 
class markOrdersAsReversalInitiated_result:
18484 
  """
18485 
  Attributes:
18486 
   - ex
18487 
  """
18488 
 
18489 
  thrift_spec = (
18490 
    None, # 0
18491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18492 
  )
18493 
 
18494 
  def __init__(self, ex=None,):
18495 
    self.ex = ex
18496 
 
18497 
  def read(self, iprot):
18498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18500 
      return
18501 
    iprot.readStructBegin()
18502 
    while True:
18503 
      (fname, ftype, fid) = iprot.readFieldBegin()
18504 
      if ftype == TType.STOP:
18505 
        break
18506 
      if fid == 1:
18507 
        if ftype == TType.STRUCT:
18508 
          self.ex = TransactionServiceException()
18509 
          self.ex.read(iprot)
18510 
        else:
18511 
          iprot.skip(ftype)
18512 
      else:
18513 
        iprot.skip(ftype)
18514 
      iprot.readFieldEnd()
18515 
    iprot.readStructEnd()
18516 
 
18517 
  def write(self, oprot):
18518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18520 
      return
18521 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18522 
    if self.ex is not None:
18523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18524 
      self.ex.write(oprot)
18525 
      oprot.writeFieldEnd()
18526 
    oprot.writeFieldStop()
18527 
    oprot.writeStructEnd()
18528 
 
18529 
  def validate(self):
18530 
    return
18531 
 
18532 
 
18533 
  def __repr__(self):
18534 
    L = ['%s=%r' % (key, value)
18535 
      for key, value in self.__dict__.iteritems()]
18536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18537 
 
18538 
  def __eq__(self, other):
18539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18540 
 
18541 
  def __ne__(self, other):
18542 
    return not (self == other)
18543 
 
18544 
class markOrdersAsNotAvailabke_args:
18545 
  """
18546 
  Attributes:
18547 
   - vendorId
18548 
   - itemId
18549 
   - quantity
18550 
   - estimate
4369 rajveer 18551 
   - isReminder
4303 rajveer 18552 
  """
18553 
 
18554 
  thrift_spec = (
18555 
    None, # 0
18556 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18557 
    (2, TType.I64, 'itemId', None, None, ), # 2
18558 
    (3, TType.I64, 'quantity', None, None, ), # 3
18559 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18560 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18561 
  )
18562 
 
4369 rajveer 18563 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18564 
    self.vendorId = vendorId
18565 
    self.itemId = itemId
18566 
    self.quantity = quantity
18567 
    self.estimate = estimate
4369 rajveer 18568 
    self.isReminder = isReminder
4303 rajveer 18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 1:
18580 
        if ftype == TType.I64:
18581 
          self.vendorId = iprot.readI64();
18582 
        else:
18583 
          iprot.skip(ftype)
18584 
      elif fid == 2:
18585 
        if ftype == TType.I64:
18586 
          self.itemId = iprot.readI64();
18587 
        else:
18588 
          iprot.skip(ftype)
18589 
      elif fid == 3:
18590 
        if ftype == TType.I64:
18591 
          self.quantity = iprot.readI64();
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      elif fid == 4:
18595 
        if ftype == TType.I64:
18596 
          self.estimate = iprot.readI64();
18597 
        else:
18598 
          iprot.skip(ftype)
4369 rajveer 18599 
      elif fid == 5:
18600 
        if ftype == TType.BOOL:
18601 
          self.isReminder = iprot.readBool();
18602 
        else:
18603 
          iprot.skip(ftype)
4303 rajveer 18604 
      else:
18605 
        iprot.skip(ftype)
18606 
      iprot.readFieldEnd()
18607 
    iprot.readStructEnd()
18608 
 
18609 
  def write(self, oprot):
18610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18612 
      return
18613 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18614 
    if self.vendorId is not None:
18615 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18616 
      oprot.writeI64(self.vendorId)
18617 
      oprot.writeFieldEnd()
18618 
    if self.itemId is not None:
18619 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18620 
      oprot.writeI64(self.itemId)
18621 
      oprot.writeFieldEnd()
18622 
    if self.quantity is not None:
18623 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18624 
      oprot.writeI64(self.quantity)
18625 
      oprot.writeFieldEnd()
18626 
    if self.estimate is not None:
18627 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18628 
      oprot.writeI64(self.estimate)
18629 
      oprot.writeFieldEnd()
4369 rajveer 18630 
    if self.isReminder is not None:
18631 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18632 
      oprot.writeBool(self.isReminder)
18633 
      oprot.writeFieldEnd()
4303 rajveer 18634 
    oprot.writeFieldStop()
18635 
    oprot.writeStructEnd()
18636 
 
18637 
  def validate(self):
18638 
    return
18639 
 
18640 
 
18641 
  def __repr__(self):
18642 
    L = ['%s=%r' % (key, value)
18643 
      for key, value in self.__dict__.iteritems()]
18644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18645 
 
18646 
  def __eq__(self, other):
18647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18648 
 
18649 
  def __ne__(self, other):
18650 
    return not (self == other)
18651 
 
18652 
class markOrdersAsNotAvailabke_result:
18653 
  """
18654 
  Attributes:
18655 
   - ex
18656 
  """
18657 
 
18658 
  thrift_spec = (
18659 
    None, # 0
18660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18661 
  )
18662 
 
18663 
  def __init__(self, ex=None,):
18664 
    self.ex = ex
18665 
 
18666 
  def read(self, iprot):
18667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18669 
      return
18670 
    iprot.readStructBegin()
18671 
    while True:
18672 
      (fname, ftype, fid) = iprot.readFieldBegin()
18673 
      if ftype == TType.STOP:
18674 
        break
18675 
      if fid == 1:
18676 
        if ftype == TType.STRUCT:
18677 
          self.ex = TransactionServiceException()
18678 
          self.ex.read(iprot)
18679 
        else:
18680 
          iprot.skip(ftype)
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
18691 
    if self.ex is not None:
18692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18693 
      self.ex.write(oprot)
18694 
      oprot.writeFieldEnd()
18695 
    oprot.writeFieldStop()
18696 
    oprot.writeStructEnd()
18697 
 
18698 
  def validate(self):
18699 
    return
18700 
 
18701 
 
18702 
  def __repr__(self):
18703 
    L = ['%s=%r' % (key, value)
18704 
      for key, value in self.__dict__.iteritems()]
18705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18706 
 
18707 
  def __eq__(self, other):
18708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18709 
 
18710 
  def __ne__(self, other):
18711 
    return not (self == other)
4369 rajveer 18712 
 
18713 
class markOrdersAsTimeout_args:
18714 
  """
18715 
  Attributes:
18716 
   - vendorId
18717 
  """
18718 
 
18719 
  thrift_spec = (
18720 
    None, # 0
18721 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18722 
  )
18723 
 
18724 
  def __init__(self, vendorId=None,):
18725 
    self.vendorId = vendorId
18726 
 
18727 
  def read(self, iprot):
18728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18730 
      return
18731 
    iprot.readStructBegin()
18732 
    while True:
18733 
      (fname, ftype, fid) = iprot.readFieldBegin()
18734 
      if ftype == TType.STOP:
18735 
        break
18736 
      if fid == 1:
18737 
        if ftype == TType.I64:
18738 
          self.vendorId = iprot.readI64();
18739 
        else:
18740 
          iprot.skip(ftype)
18741 
      else:
18742 
        iprot.skip(ftype)
18743 
      iprot.readFieldEnd()
18744 
    iprot.readStructEnd()
18745 
 
18746 
  def write(self, oprot):
18747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18749 
      return
18750 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
18751 
    if self.vendorId is not None:
18752 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18753 
      oprot.writeI64(self.vendorId)
18754 
      oprot.writeFieldEnd()
18755 
    oprot.writeFieldStop()
18756 
    oprot.writeStructEnd()
18757 
 
18758 
  def validate(self):
18759 
    return
18760 
 
18761 
 
18762 
  def __repr__(self):
18763 
    L = ['%s=%r' % (key, value)
18764 
      for key, value in self.__dict__.iteritems()]
18765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18766 
 
18767 
  def __eq__(self, other):
18768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18769 
 
18770 
  def __ne__(self, other):
18771 
    return not (self == other)
18772 
 
18773 
class markOrdersAsTimeout_result:
18774 
  """
18775 
  Attributes:
18776 
   - success
18777 
   - ex
18778 
  """
18779 
 
18780 
  thrift_spec = (
18781 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
18782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18783 
  )
18784 
 
18785 
  def __init__(self, success=None, ex=None,):
18786 
    self.success = success
18787 
    self.ex = ex
18788 
 
18789 
  def read(self, iprot):
18790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18792 
      return
18793 
    iprot.readStructBegin()
18794 
    while True:
18795 
      (fname, ftype, fid) = iprot.readFieldBegin()
18796 
      if ftype == TType.STOP:
18797 
        break
18798 
      if fid == 0:
18799 
        if ftype == TType.MAP:
18800 
          self.success = {}
4910 phani.kuma 18801 
          (_ktype375, _vtype376, _size374 ) = iprot.readMapBegin()
18802 
          for _i378 in xrange(_size374):
18803 
            _key379 = iprot.readI32();
18804 
            _val380 = TimeoutSummary()
18805 
            _val380.read(iprot)
18806 
            self.success[_key379] = _val380
4369 rajveer 18807 
          iprot.readMapEnd()
18808 
        else:
18809 
          iprot.skip(ftype)
18810 
      elif fid == 1:
18811 
        if ftype == TType.STRUCT:
18812 
          self.ex = TransactionServiceException()
18813 
          self.ex.read(iprot)
18814 
        else:
18815 
          iprot.skip(ftype)
18816 
      else:
18817 
        iprot.skip(ftype)
18818 
      iprot.readFieldEnd()
18819 
    iprot.readStructEnd()
18820 
 
18821 
  def write(self, oprot):
18822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18824 
      return
18825 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
18826 
    if self.success is not None:
18827 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18828 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4910 phani.kuma 18829 
      for kiter381,viter382 in self.success.items():
18830 
        oprot.writeI32(kiter381)
18831 
        viter382.write(oprot)
4369 rajveer 18832 
      oprot.writeMapEnd()
18833 
      oprot.writeFieldEnd()
18834 
    if self.ex is not None:
18835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18836 
      self.ex.write(oprot)
18837 
      oprot.writeFieldEnd()
18838 
    oprot.writeFieldStop()
18839 
    oprot.writeStructEnd()
18840 
 
18841 
  def validate(self):
18842 
    return
18843 
 
18844 
 
18845 
  def __repr__(self):
18846 
    L = ['%s=%r' % (key, value)
18847 
      for key, value in self.__dict__.iteritems()]
18848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18849 
 
18850 
  def __eq__(self, other):
18851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18852 
 
18853 
  def __ne__(self, other):
18854 
    return not (self == other)
4386 anupam.sin 18855 
 
4662 rajveer 18856 
class markOrderAsLostInTransit_args:
18857 
  """
18858 
  Attributes:
18859 
   - orderId
18860 
  """
18861 
 
18862 
  thrift_spec = (
18863 
    None, # 0
18864 
    (1, TType.I64, 'orderId', None, None, ), # 1
18865 
  )
18866 
 
18867 
  def __init__(self, orderId=None,):
18868 
    self.orderId = orderId
18869 
 
18870 
  def read(self, iprot):
18871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18873 
      return
18874 
    iprot.readStructBegin()
18875 
    while True:
18876 
      (fname, ftype, fid) = iprot.readFieldBegin()
18877 
      if ftype == TType.STOP:
18878 
        break
18879 
      if fid == 1:
18880 
        if ftype == TType.I64:
18881 
          self.orderId = iprot.readI64();
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      else:
18885 
        iprot.skip(ftype)
18886 
      iprot.readFieldEnd()
18887 
    iprot.readStructEnd()
18888 
 
18889 
  def write(self, oprot):
18890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18892 
      return
18893 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
18894 
    if self.orderId is not None:
18895 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18896 
      oprot.writeI64(self.orderId)
18897 
      oprot.writeFieldEnd()
18898 
    oprot.writeFieldStop()
18899 
    oprot.writeStructEnd()
18900 
 
18901 
  def validate(self):
18902 
    return
18903 
 
18904 
 
18905 
  def __repr__(self):
18906 
    L = ['%s=%r' % (key, value)
18907 
      for key, value in self.__dict__.iteritems()]
18908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18909 
 
18910 
  def __eq__(self, other):
18911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18912 
 
18913 
  def __ne__(self, other):
18914 
    return not (self == other)
18915 
 
18916 
class markOrderAsLostInTransit_result:
18917 
  """
18918 
  Attributes:
18919 
   - success
18920 
   - ex
18921 
  """
18922 
 
18923 
  thrift_spec = (
18924 
    (0, TType.BOOL, 'success', None, None, ), # 0
18925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18926 
  )
18927 
 
18928 
  def __init__(self, success=None, ex=None,):
18929 
    self.success = success
18930 
    self.ex = ex
18931 
 
18932 
  def read(self, iprot):
18933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18935 
      return
18936 
    iprot.readStructBegin()
18937 
    while True:
18938 
      (fname, ftype, fid) = iprot.readFieldBegin()
18939 
      if ftype == TType.STOP:
18940 
        break
18941 
      if fid == 0:
18942 
        if ftype == TType.BOOL:
18943 
          self.success = iprot.readBool();
18944 
        else:
18945 
          iprot.skip(ftype)
18946 
      elif fid == 1:
18947 
        if ftype == TType.STRUCT:
18948 
          self.ex = TransactionServiceException()
18949 
          self.ex.read(iprot)
18950 
        else:
18951 
          iprot.skip(ftype)
18952 
      else:
18953 
        iprot.skip(ftype)
18954 
      iprot.readFieldEnd()
18955 
    iprot.readStructEnd()
18956 
 
18957 
  def write(self, oprot):
18958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18960 
      return
18961 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
18962 
    if self.success is not None:
18963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18964 
      oprot.writeBool(self.success)
18965 
      oprot.writeFieldEnd()
18966 
    if self.ex is not None:
18967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18968 
      self.ex.write(oprot)
18969 
      oprot.writeFieldEnd()
18970 
    oprot.writeFieldStop()
18971 
    oprot.writeStructEnd()
18972 
 
18973 
  def validate(self):
18974 
    return
18975 
 
18976 
 
18977 
  def __repr__(self):
18978 
    L = ['%s=%r' % (key, value)
18979 
      for key, value in self.__dict__.iteritems()]
18980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18981 
 
18982 
  def __eq__(self, other):
18983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18984 
 
18985 
  def __ne__(self, other):
18986 
    return not (self == other)
18987 
 
4386 anupam.sin 18988 
class getOrderForAwb_args:
18989 
  """
18990 
  Attributes:
18991 
   - awb
18992 
  """
18993 
 
18994 
  thrift_spec = (
18995 
    None, # 0
18996 
    (1, TType.STRING, 'awb', None, None, ), # 1
18997 
  )
18998 
 
18999 
  def __init__(self, awb=None,):
19000 
    self.awb = awb
19001 
 
19002 
  def read(self, iprot):
19003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19005 
      return
19006 
    iprot.readStructBegin()
19007 
    while True:
19008 
      (fname, ftype, fid) = iprot.readFieldBegin()
19009 
      if ftype == TType.STOP:
19010 
        break
19011 
      if fid == 1:
19012 
        if ftype == TType.STRING:
19013 
          self.awb = iprot.readString();
19014 
        else:
19015 
          iprot.skip(ftype)
19016 
      else:
19017 
        iprot.skip(ftype)
19018 
      iprot.readFieldEnd()
19019 
    iprot.readStructEnd()
19020 
 
19021 
  def write(self, oprot):
19022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19024 
      return
19025 
    oprot.writeStructBegin('getOrderForAwb_args')
19026 
    if self.awb is not None:
19027 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19028 
      oprot.writeString(self.awb)
19029 
      oprot.writeFieldEnd()
19030 
    oprot.writeFieldStop()
19031 
    oprot.writeStructEnd()
19032 
 
19033 
  def validate(self):
19034 
    return
19035 
 
19036 
 
19037 
  def __repr__(self):
19038 
    L = ['%s=%r' % (key, value)
19039 
      for key, value in self.__dict__.iteritems()]
19040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19041 
 
19042 
  def __eq__(self, other):
19043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19044 
 
19045 
  def __ne__(self, other):
19046 
    return not (self == other)
19047 
 
19048 
class getOrderForAwb_result:
19049 
  """
19050 
  Attributes:
19051 
   - success
19052 
   - ex
19053 
  """
19054 
 
19055 
  thrift_spec = (
19056 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19058 
  )
19059 
 
19060 
  def __init__(self, success=None, ex=None,):
19061 
    self.success = success
19062 
    self.ex = ex
19063 
 
19064 
  def read(self, iprot):
19065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19067 
      return
19068 
    iprot.readStructBegin()
19069 
    while True:
19070 
      (fname, ftype, fid) = iprot.readFieldBegin()
19071 
      if ftype == TType.STOP:
19072 
        break
19073 
      if fid == 0:
19074 
        if ftype == TType.STRUCT:
19075 
          self.success = Order()
19076 
          self.success.read(iprot)
19077 
        else:
19078 
          iprot.skip(ftype)
19079 
      elif fid == 1:
19080 
        if ftype == TType.STRUCT:
19081 
          self.ex = TransactionServiceException()
19082 
          self.ex.read(iprot)
19083 
        else:
19084 
          iprot.skip(ftype)
19085 
      else:
19086 
        iprot.skip(ftype)
19087 
      iprot.readFieldEnd()
19088 
    iprot.readStructEnd()
19089 
 
19090 
  def write(self, oprot):
19091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19093 
      return
19094 
    oprot.writeStructBegin('getOrderForAwb_result')
19095 
    if self.success is not None:
19096 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19097 
      self.success.write(oprot)
19098 
      oprot.writeFieldEnd()
19099 
    if self.ex is not None:
19100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19101 
      self.ex.write(oprot)
19102 
      oprot.writeFieldEnd()
19103 
    oprot.writeFieldStop()
19104 
    oprot.writeStructEnd()
19105 
 
19106 
  def validate(self):
19107 
    return
19108 
 
19109 
 
19110 
  def __repr__(self):
19111 
    L = ['%s=%r' % (key, value)
19112 
      for key, value in self.__dict__.iteritems()]
19113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19114 
 
19115 
  def __eq__(self, other):
19116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19117 
 
19118 
  def __ne__(self, other):
19119 
    return not (self == other)
4506 phani.kuma 19120 
 
19121 
class getOrdersForProviderForStatus_args:
19122 
  """
19123 
  Attributes:
19124 
   - logistics_provider_id
4910 phani.kuma 19125 
   - order_status_list
4506 phani.kuma 19126 
  """
19127 
 
19128 
  thrift_spec = (
19129 
    None, # 0
19130 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19131 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19132 
  )
19133 
 
4910 phani.kuma 19134 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19135 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19136 
    self.order_status_list = order_status_list
4506 phani.kuma 19137 
 
19138 
  def read(self, iprot):
19139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19141 
      return
19142 
    iprot.readStructBegin()
19143 
    while True:
19144 
      (fname, ftype, fid) = iprot.readFieldBegin()
19145 
      if ftype == TType.STOP:
19146 
        break
19147 
      if fid == 1:
19148 
        if ftype == TType.I64:
19149 
          self.logistics_provider_id = iprot.readI64();
19150 
        else:
19151 
          iprot.skip(ftype)
19152 
      elif fid == 2:
4910 phani.kuma 19153 
        if ftype == TType.LIST:
19154 
          self.order_status_list = []
19155 
          (_etype386, _size383) = iprot.readListBegin()
19156 
          for _i387 in xrange(_size383):
19157 
            _elem388 = iprot.readI32();
19158 
            self.order_status_list.append(_elem388)
19159 
          iprot.readListEnd()
4506 phani.kuma 19160 
        else:
19161 
          iprot.skip(ftype)
19162 
      else:
19163 
        iprot.skip(ftype)
19164 
      iprot.readFieldEnd()
19165 
    iprot.readStructEnd()
19166 
 
19167 
  def write(self, oprot):
19168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19170 
      return
19171 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19172 
    if self.logistics_provider_id is not None:
19173 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19174 
      oprot.writeI64(self.logistics_provider_id)
19175 
      oprot.writeFieldEnd()
4910 phani.kuma 19176 
    if self.order_status_list is not None:
19177 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19178 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
19179 
      for iter389 in self.order_status_list:
19180 
        oprot.writeI32(iter389)
19181 
      oprot.writeListEnd()
4506 phani.kuma 19182 
      oprot.writeFieldEnd()
19183 
    oprot.writeFieldStop()
19184 
    oprot.writeStructEnd()
19185 
 
19186 
  def validate(self):
19187 
    return
19188 
 
19189 
 
19190 
  def __repr__(self):
19191 
    L = ['%s=%r' % (key, value)
19192 
      for key, value in self.__dict__.iteritems()]
19193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19194 
 
19195 
  def __eq__(self, other):
19196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19197 
 
19198 
  def __ne__(self, other):
19199 
    return not (self == other)
19200 
 
19201 
class getOrdersForProviderForStatus_result:
19202 
  """
19203 
  Attributes:
19204 
   - success
19205 
   - ex
19206 
  """
19207 
 
19208 
  thrift_spec = (
19209 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19211 
  )
19212 
 
19213 
  def __init__(self, success=None, ex=None,):
19214 
    self.success = success
19215 
    self.ex = ex
19216 
 
19217 
  def read(self, iprot):
19218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19220 
      return
19221 
    iprot.readStructBegin()
19222 
    while True:
19223 
      (fname, ftype, fid) = iprot.readFieldBegin()
19224 
      if ftype == TType.STOP:
19225 
        break
19226 
      if fid == 0:
19227 
        if ftype == TType.LIST:
19228 
          self.success = []
4910 phani.kuma 19229 
          (_etype393, _size390) = iprot.readListBegin()
19230 
          for _i394 in xrange(_size390):
19231 
            _elem395 = Order()
19232 
            _elem395.read(iprot)
19233 
            self.success.append(_elem395)
4506 phani.kuma 19234 
          iprot.readListEnd()
19235 
        else:
19236 
          iprot.skip(ftype)
19237 
      elif fid == 1:
19238 
        if ftype == TType.STRUCT:
19239 
          self.ex = TransactionServiceException()
19240 
          self.ex.read(iprot)
19241 
        else:
19242 
          iprot.skip(ftype)
19243 
      else:
19244 
        iprot.skip(ftype)
19245 
      iprot.readFieldEnd()
19246 
    iprot.readStructEnd()
19247 
 
19248 
  def write(self, oprot):
19249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19251 
      return
19252 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19253 
    if self.success is not None:
19254 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19255 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 19256 
      for iter396 in self.success:
19257 
        iter396.write(oprot)
4506 phani.kuma 19258 
      oprot.writeListEnd()
19259 
      oprot.writeFieldEnd()
19260 
    if self.ex is not None:
19261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19262 
      self.ex.write(oprot)
19263 
      oprot.writeFieldEnd()
19264 
    oprot.writeFieldStop()
19265 
    oprot.writeStructEnd()
19266 
 
19267 
  def validate(self):
19268 
    return
19269 
 
19270 
 
19271 
  def __repr__(self):
19272 
    L = ['%s=%r' % (key, value)
19273 
      for key, value in self.__dict__.iteritems()]
19274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19275 
 
19276 
  def __eq__(self, other):
19277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19278 
 
19279 
  def __ne__(self, other):
19280 
    return not (self == other)
4600 varun.gupt 19281 
 
19282 
class getBilledOrdersForVendor_args:
19283 
  """
19284 
  Attributes:
19285 
   - vendorId
19286 
   - billingDateFrom
19287 
   - billingDateTo
19288 
  """
19289 
 
19290 
  thrift_spec = (
19291 
    None, # 0
19292 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19293 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19294 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19295 
  )
19296 
 
19297 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19298 
    self.vendorId = vendorId
19299 
    self.billingDateFrom = billingDateFrom
19300 
    self.billingDateTo = billingDateTo
19301 
 
19302 
  def read(self, iprot):
19303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19305 
      return
19306 
    iprot.readStructBegin()
19307 
    while True:
19308 
      (fname, ftype, fid) = iprot.readFieldBegin()
19309 
      if ftype == TType.STOP:
19310 
        break
19311 
      if fid == 1:
19312 
        if ftype == TType.I64:
19313 
          self.vendorId = iprot.readI64();
19314 
        else:
19315 
          iprot.skip(ftype)
19316 
      elif fid == 2:
19317 
        if ftype == TType.I64:
19318 
          self.billingDateFrom = iprot.readI64();
19319 
        else:
19320 
          iprot.skip(ftype)
19321 
      elif fid == 3:
19322 
        if ftype == TType.I64:
19323 
          self.billingDateTo = iprot.readI64();
19324 
        else:
19325 
          iprot.skip(ftype)
19326 
      else:
19327 
        iprot.skip(ftype)
19328 
      iprot.readFieldEnd()
19329 
    iprot.readStructEnd()
19330 
 
19331 
  def write(self, oprot):
19332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19334 
      return
19335 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19336 
    if self.vendorId is not None:
19337 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19338 
      oprot.writeI64(self.vendorId)
19339 
      oprot.writeFieldEnd()
19340 
    if self.billingDateFrom is not None:
19341 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19342 
      oprot.writeI64(self.billingDateFrom)
19343 
      oprot.writeFieldEnd()
19344 
    if self.billingDateTo is not None:
19345 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19346 
      oprot.writeI64(self.billingDateTo)
19347 
      oprot.writeFieldEnd()
19348 
    oprot.writeFieldStop()
19349 
    oprot.writeStructEnd()
19350 
 
19351 
  def validate(self):
19352 
    return
19353 
 
19354 
 
19355 
  def __repr__(self):
19356 
    L = ['%s=%r' % (key, value)
19357 
      for key, value in self.__dict__.iteritems()]
19358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19359 
 
19360 
  def __eq__(self, other):
19361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19362 
 
19363 
  def __ne__(self, other):
19364 
    return not (self == other)
19365 
 
19366 
class getBilledOrdersForVendor_result:
19367 
  """
19368 
  Attributes:
19369 
   - success
19370 
   - ex
19371 
  """
19372 
 
19373 
  thrift_spec = (
19374 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19376 
  )
19377 
 
19378 
  def __init__(self, success=None, ex=None,):
19379 
    self.success = success
19380 
    self.ex = ex
19381 
 
19382 
  def read(self, iprot):
19383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19385 
      return
19386 
    iprot.readStructBegin()
19387 
    while True:
19388 
      (fname, ftype, fid) = iprot.readFieldBegin()
19389 
      if ftype == TType.STOP:
19390 
        break
19391 
      if fid == 0:
19392 
        if ftype == TType.LIST:
19393 
          self.success = []
4910 phani.kuma 19394 
          (_etype400, _size397) = iprot.readListBegin()
19395 
          for _i401 in xrange(_size397):
19396 
            _elem402 = Order()
19397 
            _elem402.read(iprot)
19398 
            self.success.append(_elem402)
4600 varun.gupt 19399 
          iprot.readListEnd()
19400 
        else:
19401 
          iprot.skip(ftype)
19402 
      elif fid == 1:
19403 
        if ftype == TType.STRUCT:
19404 
          self.ex = TransactionServiceException()
19405 
          self.ex.read(iprot)
19406 
        else:
19407 
          iprot.skip(ftype)
19408 
      else:
19409 
        iprot.skip(ftype)
19410 
      iprot.readFieldEnd()
19411 
    iprot.readStructEnd()
19412 
 
19413 
  def write(self, oprot):
19414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19416 
      return
19417 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19418 
    if self.success is not None:
19419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 19421 
      for iter403 in self.success:
19422 
        iter403.write(oprot)
4600 varun.gupt 19423 
      oprot.writeListEnd()
19424 
      oprot.writeFieldEnd()
19425 
    if self.ex is not None:
19426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19427 
      self.ex.write(oprot)
19428 
      oprot.writeFieldEnd()
19429 
    oprot.writeFieldStop()
19430 
    oprot.writeStructEnd()
19431 
 
19432 
  def validate(self):
19433 
    return
19434 
 
19435 
 
19436 
  def __repr__(self):
19437 
    L = ['%s=%r' % (key, value)
19438 
      for key, value in self.__dict__.iteritems()]
19439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19440 
 
19441 
  def __eq__(self, other):
19442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19443 
 
19444 
  def __ne__(self, other):
19445 
    return not (self == other)
19446 
 
4607 rajveer 19447 
class getSlippedSippingDateOrders_args:
19448 
 
19449 
  thrift_spec = (
19450 
  )
19451 
 
19452 
  def read(self, iprot):
19453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19455 
      return
19456 
    iprot.readStructBegin()
19457 
    while True:
19458 
      (fname, ftype, fid) = iprot.readFieldBegin()
19459 
      if ftype == TType.STOP:
19460 
        break
19461 
      else:
19462 
        iprot.skip(ftype)
19463 
      iprot.readFieldEnd()
19464 
    iprot.readStructEnd()
19465 
 
19466 
  def write(self, oprot):
19467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19469 
      return
19470 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19471 
    oprot.writeFieldStop()
19472 
    oprot.writeStructEnd()
19473 
 
19474 
  def validate(self):
19475 
    return
19476 
 
19477 
 
19478 
  def __repr__(self):
19479 
    L = ['%s=%r' % (key, value)
19480 
      for key, value in self.__dict__.iteritems()]
19481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19482 
 
19483 
  def __eq__(self, other):
19484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19485 
 
19486 
  def __ne__(self, other):
19487 
    return not (self == other)
19488 
 
19489 
class getSlippedSippingDateOrders_result:
19490 
  """
19491 
  Attributes:
19492 
   - success
19493 
   - ex
19494 
  """
19495 
 
19496 
  thrift_spec = (
19497 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19498 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19499 
  )
19500 
 
19501 
  def __init__(self, success=None, ex=None,):
19502 
    self.success = success
19503 
    self.ex = ex
19504 
 
19505 
  def read(self, iprot):
19506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19508 
      return
19509 
    iprot.readStructBegin()
19510 
    while True:
19511 
      (fname, ftype, fid) = iprot.readFieldBegin()
19512 
      if ftype == TType.STOP:
19513 
        break
19514 
      if fid == 0:
19515 
        if ftype == TType.LIST:
19516 
          self.success = []
4910 phani.kuma 19517 
          (_etype407, _size404) = iprot.readListBegin()
19518 
          for _i408 in xrange(_size404):
19519 
            _elem409 = Order()
19520 
            _elem409.read(iprot)
19521 
            self.success.append(_elem409)
4607 rajveer 19522 
          iprot.readListEnd()
19523 
        else:
19524 
          iprot.skip(ftype)
19525 
      elif fid == 1:
19526 
        if ftype == TType.STRUCT:
19527 
          self.ex = TransactionServiceException()
19528 
          self.ex.read(iprot)
19529 
        else:
19530 
          iprot.skip(ftype)
19531 
      else:
19532 
        iprot.skip(ftype)
19533 
      iprot.readFieldEnd()
19534 
    iprot.readStructEnd()
19535 
 
19536 
  def write(self, oprot):
19537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19539 
      return
19540 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19541 
    if self.success is not None:
19542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 19544 
      for iter410 in self.success:
19545 
        iter410.write(oprot)
4607 rajveer 19546 
      oprot.writeListEnd()
19547 
      oprot.writeFieldEnd()
19548 
    if self.ex is not None:
19549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19550 
      self.ex.write(oprot)
19551 
      oprot.writeFieldEnd()
19552 
    oprot.writeFieldStop()
19553 
    oprot.writeStructEnd()
19554 
 
19555 
  def validate(self):
19556 
    return
19557 
 
19558 
 
19559 
  def __repr__(self):
19560 
    L = ['%s=%r' % (key, value)
19561 
      for key, value in self.__dict__.iteritems()]
19562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19563 
 
19564 
  def __eq__(self, other):
19565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19566 
 
19567 
  def __ne__(self, other):
19568 
    return not (self == other)
19569 
 
4709 rajveer 19570 
class getCancelledOrders_args:
19571 
  """
19572 
  Attributes:
19573 
   - cancelDateFrom
19574 
   - cancelDateTo
19575 
  """
19576 
 
19577 
  thrift_spec = (
19578 
    None, # 0
19579 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19580 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19581 
  )
19582 
 
19583 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19584 
    self.cancelDateFrom = cancelDateFrom
19585 
    self.cancelDateTo = cancelDateTo
19586 
 
19587 
  def read(self, iprot):
19588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19590 
      return
19591 
    iprot.readStructBegin()
19592 
    while True:
19593 
      (fname, ftype, fid) = iprot.readFieldBegin()
19594 
      if ftype == TType.STOP:
19595 
        break
19596 
      if fid == 1:
19597 
        if ftype == TType.I64:
19598 
          self.cancelDateFrom = iprot.readI64();
19599 
        else:
19600 
          iprot.skip(ftype)
19601 
      elif fid == 2:
19602 
        if ftype == TType.I64:
19603 
          self.cancelDateTo = iprot.readI64();
19604 
        else:
19605 
          iprot.skip(ftype)
19606 
      else:
19607 
        iprot.skip(ftype)
19608 
      iprot.readFieldEnd()
19609 
    iprot.readStructEnd()
19610 
 
19611 
  def write(self, oprot):
19612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19614 
      return
19615 
    oprot.writeStructBegin('getCancelledOrders_args')
19616 
    if self.cancelDateFrom is not None:
19617 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19618 
      oprot.writeI64(self.cancelDateFrom)
19619 
      oprot.writeFieldEnd()
19620 
    if self.cancelDateTo is not None:
19621 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19622 
      oprot.writeI64(self.cancelDateTo)
19623 
      oprot.writeFieldEnd()
19624 
    oprot.writeFieldStop()
19625 
    oprot.writeStructEnd()
19626 
 
19627 
  def validate(self):
19628 
    return
19629 
 
19630 
 
19631 
  def __repr__(self):
19632 
    L = ['%s=%r' % (key, value)
19633 
      for key, value in self.__dict__.iteritems()]
19634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19635 
 
19636 
  def __eq__(self, other):
19637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19638 
 
19639 
  def __ne__(self, other):
19640 
    return not (self == other)
19641 
 
19642 
class getCancelledOrders_result:
19643 
  """
19644 
  Attributes:
19645 
   - success
19646 
   - ex
19647 
  """
19648 
 
19649 
  thrift_spec = (
19650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19652 
  )
19653 
 
19654 
  def __init__(self, success=None, ex=None,):
19655 
    self.success = success
19656 
    self.ex = ex
19657 
 
19658 
  def read(self, iprot):
19659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19661 
      return
19662 
    iprot.readStructBegin()
19663 
    while True:
19664 
      (fname, ftype, fid) = iprot.readFieldBegin()
19665 
      if ftype == TType.STOP:
19666 
        break
19667 
      if fid == 0:
19668 
        if ftype == TType.LIST:
19669 
          self.success = []
4910 phani.kuma 19670 
          (_etype414, _size411) = iprot.readListBegin()
19671 
          for _i415 in xrange(_size411):
19672 
            _elem416 = Order()
19673 
            _elem416.read(iprot)
19674 
            self.success.append(_elem416)
4709 rajveer 19675 
          iprot.readListEnd()
19676 
        else:
19677 
          iprot.skip(ftype)
19678 
      elif fid == 1:
19679 
        if ftype == TType.STRUCT:
19680 
          self.ex = TransactionServiceException()
19681 
          self.ex.read(iprot)
19682 
        else:
19683 
          iprot.skip(ftype)
19684 
      else:
19685 
        iprot.skip(ftype)
19686 
      iprot.readFieldEnd()
19687 
    iprot.readStructEnd()
19688 
 
19689 
  def write(self, oprot):
19690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19692 
      return
19693 
    oprot.writeStructBegin('getCancelledOrders_result')
19694 
    if self.success is not None:
19695 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19696 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 19697 
      for iter417 in self.success:
19698 
        iter417.write(oprot)
4709 rajveer 19699 
      oprot.writeListEnd()
19700 
      oprot.writeFieldEnd()
19701 
    if self.ex is not None:
19702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19703 
      self.ex.write(oprot)
19704 
      oprot.writeFieldEnd()
19705 
    oprot.writeFieldStop()
19706 
    oprot.writeStructEnd()
19707 
 
19708 
  def validate(self):
19709 
    return
19710 
 
19711 
 
19712 
  def __repr__(self):
19713 
    L = ['%s=%r' % (key, value)
19714 
      for key, value in self.__dict__.iteritems()]
19715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19716 
 
19717 
  def __eq__(self, other):
19718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19719 
 
19720 
  def __ne__(self, other):
19721 
    return not (self == other)
19722 
 
4600 varun.gupt 19723 
class saveBluedartSettlements_args:
19724 
  """
19725 
  Attributes:
19726 
   - mapAWBAndAmount
19727 
  """
19728 
 
19729 
  thrift_spec = (
19730 
    None, # 0
19731 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
19732 
  )
19733 
 
19734 
  def __init__(self, mapAWBAndAmount=None,):
19735 
    self.mapAWBAndAmount = mapAWBAndAmount
19736 
 
19737 
  def read(self, iprot):
19738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19740 
      return
19741 
    iprot.readStructBegin()
19742 
    while True:
19743 
      (fname, ftype, fid) = iprot.readFieldBegin()
19744 
      if ftype == TType.STOP:
19745 
        break
19746 
      if fid == 1:
19747 
        if ftype == TType.MAP:
19748 
          self.mapAWBAndAmount = {}
4910 phani.kuma 19749 
          (_ktype419, _vtype420, _size418 ) = iprot.readMapBegin()
19750 
          for _i422 in xrange(_size418):
19751 
            _key423 = iprot.readI64();
19752 
            _val424 = iprot.readDouble();
19753 
            self.mapAWBAndAmount[_key423] = _val424
4600 varun.gupt 19754 
          iprot.readMapEnd()
19755 
        else:
19756 
          iprot.skip(ftype)
19757 
      else:
19758 
        iprot.skip(ftype)
19759 
      iprot.readFieldEnd()
19760 
    iprot.readStructEnd()
19761 
 
19762 
  def write(self, oprot):
19763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19765 
      return
19766 
    oprot.writeStructBegin('saveBluedartSettlements_args')
19767 
    if self.mapAWBAndAmount is not None:
19768 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
19769 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4910 phani.kuma 19770 
      for kiter425,viter426 in self.mapAWBAndAmount.items():
19771 
        oprot.writeI64(kiter425)
19772 
        oprot.writeDouble(viter426)
4600 varun.gupt 19773 
      oprot.writeMapEnd()
19774 
      oprot.writeFieldEnd()
19775 
    oprot.writeFieldStop()
19776 
    oprot.writeStructEnd()
19777 
 
19778 
  def validate(self):
19779 
    return
19780 
 
19781 
 
19782 
  def __repr__(self):
19783 
    L = ['%s=%r' % (key, value)
19784 
      for key, value in self.__dict__.iteritems()]
19785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19786 
 
19787 
  def __eq__(self, other):
19788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19789 
 
19790 
  def __ne__(self, other):
19791 
    return not (self == other)
19792 
 
19793 
class saveBluedartSettlements_result:
19794 
  """
19795 
  Attributes:
19796 
   - ex
19797 
  """
19798 
 
19799 
  thrift_spec = (
19800 
    None, # 0
19801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19802 
  )
19803 
 
19804 
  def __init__(self, ex=None,):
19805 
    self.ex = ex
19806 
 
19807 
  def read(self, iprot):
19808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19810 
      return
19811 
    iprot.readStructBegin()
19812 
    while True:
19813 
      (fname, ftype, fid) = iprot.readFieldBegin()
19814 
      if ftype == TType.STOP:
19815 
        break
19816 
      if fid == 1:
19817 
        if ftype == TType.STRUCT:
19818 
          self.ex = TransactionServiceException()
19819 
          self.ex.read(iprot)
19820 
        else:
19821 
          iprot.skip(ftype)
19822 
      else:
19823 
        iprot.skip(ftype)
19824 
      iprot.readFieldEnd()
19825 
    iprot.readStructEnd()
19826 
 
19827 
  def write(self, oprot):
19828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19830 
      return
19831 
    oprot.writeStructBegin('saveBluedartSettlements_result')
19832 
    if self.ex is not None:
19833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19834 
      self.ex.write(oprot)
19835 
      oprot.writeFieldEnd()
19836 
    oprot.writeFieldStop()
19837 
    oprot.writeStructEnd()
19838 
 
19839 
  def validate(self):
19840 
    return
19841 
 
19842 
 
19843 
  def __repr__(self):
19844 
    L = ['%s=%r' % (key, value)
19845 
      for key, value in self.__dict__.iteritems()]
19846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19847 
 
19848 
  def __eq__(self, other):
19849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19850 
 
19851 
  def __ne__(self, other):
19852 
    return not (self == other)
19853 
 
19854 
class savePaymentSettlements_args:
19855 
  """
19856 
  Attributes:
19857 
   - settlementDate
19858 
   - paymentGatewayId
4905 varun.gupt 19859 
   - referenceId
4600 varun.gupt 19860 
   - serviceTax
19861 
   - otherCharges
19862 
   - netCollection
19863 
  """
19864 
 
19865 
  thrift_spec = (
19866 
    None, # 0
19867 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
19868 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 19869 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 19870 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
19871 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
19872 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
19873 
  )
19874 
 
4905 varun.gupt 19875 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 19876 
    self.settlementDate = settlementDate
19877 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 19878 
    self.referenceId = referenceId
4600 varun.gupt 19879 
    self.serviceTax = serviceTax
19880 
    self.otherCharges = otherCharges
19881 
    self.netCollection = netCollection
19882 
 
19883 
  def read(self, iprot):
19884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19886 
      return
19887 
    iprot.readStructBegin()
19888 
    while True:
19889 
      (fname, ftype, fid) = iprot.readFieldBegin()
19890 
      if ftype == TType.STOP:
19891 
        break
19892 
      if fid == 1:
19893 
        if ftype == TType.I64:
19894 
          self.settlementDate = iprot.readI64();
19895 
        else:
19896 
          iprot.skip(ftype)
19897 
      elif fid == 2:
19898 
        if ftype == TType.I64:
19899 
          self.paymentGatewayId = iprot.readI64();
19900 
        else:
19901 
          iprot.skip(ftype)
19902 
      elif fid == 3:
19903 
        if ftype == TType.I64:
4905 varun.gupt 19904 
          self.referenceId = iprot.readI64();
4600 varun.gupt 19905 
        else:
19906 
          iprot.skip(ftype)
19907 
      elif fid == 4:
19908 
        if ftype == TType.DOUBLE:
19909 
          self.serviceTax = iprot.readDouble();
19910 
        else:
19911 
          iprot.skip(ftype)
19912 
      elif fid == 5:
19913 
        if ftype == TType.DOUBLE:
19914 
          self.otherCharges = iprot.readDouble();
19915 
        else:
19916 
          iprot.skip(ftype)
19917 
      elif fid == 6:
19918 
        if ftype == TType.DOUBLE:
19919 
          self.netCollection = iprot.readDouble();
19920 
        else:
19921 
          iprot.skip(ftype)
19922 
      else:
19923 
        iprot.skip(ftype)
19924 
      iprot.readFieldEnd()
19925 
    iprot.readStructEnd()
19926 
 
19927 
  def write(self, oprot):
19928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19930 
      return
19931 
    oprot.writeStructBegin('savePaymentSettlements_args')
19932 
    if self.settlementDate is not None:
19933 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
19934 
      oprot.writeI64(self.settlementDate)
19935 
      oprot.writeFieldEnd()
19936 
    if self.paymentGatewayId is not None:
19937 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
19938 
      oprot.writeI64(self.paymentGatewayId)
19939 
      oprot.writeFieldEnd()
4905 varun.gupt 19940 
    if self.referenceId is not None:
19941 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
19942 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 19943 
      oprot.writeFieldEnd()
19944 
    if self.serviceTax is not None:
19945 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
19946 
      oprot.writeDouble(self.serviceTax)
19947 
      oprot.writeFieldEnd()
19948 
    if self.otherCharges is not None:
19949 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
19950 
      oprot.writeDouble(self.otherCharges)
19951 
      oprot.writeFieldEnd()
19952 
    if self.netCollection is not None:
19953 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
19954 
      oprot.writeDouble(self.netCollection)
19955 
      oprot.writeFieldEnd()
19956 
    oprot.writeFieldStop()
19957 
    oprot.writeStructEnd()
19958 
 
19959 
  def validate(self):
19960 
    return
19961 
 
19962 
 
19963 
  def __repr__(self):
19964 
    L = ['%s=%r' % (key, value)
19965 
      for key, value in self.__dict__.iteritems()]
19966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19967 
 
19968 
  def __eq__(self, other):
19969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19970 
 
19971 
  def __ne__(self, other):
19972 
    return not (self == other)
19973 
 
19974 
class savePaymentSettlements_result:
19975 
  """
19976 
  Attributes:
19977 
   - ex
19978 
  """
19979 
 
19980 
  thrift_spec = (
19981 
    None, # 0
19982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19983 
  )
19984 
 
19985 
  def __init__(self, ex=None,):
19986 
    self.ex = ex
19987 
 
19988 
  def read(self, iprot):
19989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19991 
      return
19992 
    iprot.readStructBegin()
19993 
    while True:
19994 
      (fname, ftype, fid) = iprot.readFieldBegin()
19995 
      if ftype == TType.STOP:
19996 
        break
19997 
      if fid == 1:
19998 
        if ftype == TType.STRUCT:
19999 
          self.ex = TransactionServiceException()
20000 
          self.ex.read(iprot)
20001 
        else:
20002 
          iprot.skip(ftype)
20003 
      else:
20004 
        iprot.skip(ftype)
20005 
      iprot.readFieldEnd()
20006 
    iprot.readStructEnd()
20007 
 
20008 
  def write(self, oprot):
20009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20011 
      return
20012 
    oprot.writeStructBegin('savePaymentSettlements_result')
20013 
    if self.ex is not None:
20014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20015 
      self.ex.write(oprot)
20016 
      oprot.writeFieldEnd()
20017 
    oprot.writeFieldStop()
20018 
    oprot.writeStructEnd()
20019 
 
20020 
  def validate(self):
20021 
    return
20022 
 
20023 
 
20024 
  def __repr__(self):
20025 
    L = ['%s=%r' % (key, value)
20026 
      for key, value in self.__dict__.iteritems()]
20027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20028 
 
20029 
  def __eq__(self, other):
20030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20031 
 
20032 
  def __ne__(self, other):
20033 
    return not (self == other)
20034 
 
20035 
class saveEBSSettlementSummary_args:
20036 
  """
20037 
  Attributes:
20038 
   - settlementId
20039 
   - settlementDate
20040 
   - transactionDateFrom
20041 
   - transactionDateTo
20042 
   - amount
20043 
  """
20044 
 
20045 
  thrift_spec = (
20046 
    None, # 0
20047 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20048 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20049 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20050 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20051 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20052 
  )
20053 
 
20054 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20055 
    self.settlementId = settlementId
20056 
    self.settlementDate = settlementDate
20057 
    self.transactionDateFrom = transactionDateFrom
20058 
    self.transactionDateTo = transactionDateTo
20059 
    self.amount = amount
20060 
 
20061 
  def read(self, iprot):
20062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20064 
      return
20065 
    iprot.readStructBegin()
20066 
    while True:
20067 
      (fname, ftype, fid) = iprot.readFieldBegin()
20068 
      if ftype == TType.STOP:
20069 
        break
20070 
      if fid == 1:
20071 
        if ftype == TType.I64:
20072 
          self.settlementId = iprot.readI64();
20073 
        else:
20074 
          iprot.skip(ftype)
20075 
      elif fid == 2:
20076 
        if ftype == TType.I64:
20077 
          self.settlementDate = iprot.readI64();
20078 
        else:
20079 
          iprot.skip(ftype)
20080 
      elif fid == 3:
20081 
        if ftype == TType.I64:
20082 
          self.transactionDateFrom = iprot.readI64();
20083 
        else:
20084 
          iprot.skip(ftype)
20085 
      elif fid == 4:
20086 
        if ftype == TType.I64:
20087 
          self.transactionDateTo = iprot.readI64();
20088 
        else:
20089 
          iprot.skip(ftype)
20090 
      elif fid == 5:
20091 
        if ftype == TType.DOUBLE:
20092 
          self.amount = iprot.readDouble();
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20105 
    if self.settlementId is not None:
20106 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20107 
      oprot.writeI64(self.settlementId)
20108 
      oprot.writeFieldEnd()
20109 
    if self.settlementDate is not None:
20110 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20111 
      oprot.writeI64(self.settlementDate)
20112 
      oprot.writeFieldEnd()
20113 
    if self.transactionDateFrom is not None:
20114 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20115 
      oprot.writeI64(self.transactionDateFrom)
20116 
      oprot.writeFieldEnd()
20117 
    if self.transactionDateTo is not None:
20118 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20119 
      oprot.writeI64(self.transactionDateTo)
20120 
      oprot.writeFieldEnd()
20121 
    if self.amount is not None:
20122 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20123 
      oprot.writeDouble(self.amount)
20124 
      oprot.writeFieldEnd()
20125 
    oprot.writeFieldStop()
20126 
    oprot.writeStructEnd()
20127 
 
20128 
  def validate(self):
20129 
    return
20130 
 
20131 
 
20132 
  def __repr__(self):
20133 
    L = ['%s=%r' % (key, value)
20134 
      for key, value in self.__dict__.iteritems()]
20135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20136 
 
20137 
  def __eq__(self, other):
20138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20139 
 
20140 
  def __ne__(self, other):
20141 
    return not (self == other)
20142 
 
20143 
class saveEBSSettlementSummary_result:
20144 
  """
20145 
  Attributes:
20146 
   - ex
20147 
  """
20148 
 
20149 
  thrift_spec = (
20150 
    None, # 0
20151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20152 
  )
20153 
 
20154 
  def __init__(self, ex=None,):
20155 
    self.ex = ex
20156 
 
20157 
  def read(self, iprot):
20158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20160 
      return
20161 
    iprot.readStructBegin()
20162 
    while True:
20163 
      (fname, ftype, fid) = iprot.readFieldBegin()
20164 
      if ftype == TType.STOP:
20165 
        break
20166 
      if fid == 1:
20167 
        if ftype == TType.STRUCT:
20168 
          self.ex = TransactionServiceException()
20169 
          self.ex.read(iprot)
20170 
        else:
20171 
          iprot.skip(ftype)
20172 
      else:
20173 
        iprot.skip(ftype)
20174 
      iprot.readFieldEnd()
20175 
    iprot.readStructEnd()
20176 
 
20177 
  def write(self, oprot):
20178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20180 
      return
20181 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20182 
    if self.ex is not None:
20183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20184 
      self.ex.write(oprot)
20185 
      oprot.writeFieldEnd()
20186 
    oprot.writeFieldStop()
20187 
    oprot.writeStructEnd()
20188 
 
20189 
  def validate(self):
20190 
    return
20191 
 
20192 
 
20193 
  def __repr__(self):
20194 
    L = ['%s=%r' % (key, value)
20195 
      for key, value in self.__dict__.iteritems()]
20196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20197 
 
20198 
  def __eq__(self, other):
20199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20200 
 
20201 
  def __ne__(self, other):
20202 
    return not (self == other)
20203 
 
20204 
class getSettlementForPaymentId_args:
20205 
  """
20206 
  Attributes:
20207 
   - paymentId
20208 
  """
20209 
 
20210 
  thrift_spec = (
20211 
    None, # 0
20212 
    (1, TType.I64, 'paymentId', None, None, ), # 1
20213 
  )
20214 
 
20215 
  def __init__(self, paymentId=None,):
20216 
    self.paymentId = paymentId
20217 
 
20218 
  def read(self, iprot):
20219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20221 
      return
20222 
    iprot.readStructBegin()
20223 
    while True:
20224 
      (fname, ftype, fid) = iprot.readFieldBegin()
20225 
      if ftype == TType.STOP:
20226 
        break
20227 
      if fid == 1:
20228 
        if ftype == TType.I64:
20229 
          self.paymentId = iprot.readI64();
20230 
        else:
20231 
          iprot.skip(ftype)
20232 
      else:
20233 
        iprot.skip(ftype)
20234 
      iprot.readFieldEnd()
20235 
    iprot.readStructEnd()
20236 
 
20237 
  def write(self, oprot):
20238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20240 
      return
20241 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
20242 
    if self.paymentId is not None:
20243 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
20244 
      oprot.writeI64(self.paymentId)
20245 
      oprot.writeFieldEnd()
20246 
    oprot.writeFieldStop()
20247 
    oprot.writeStructEnd()
20248 
 
20249 
  def validate(self):
20250 
    return
20251 
 
20252 
 
20253 
  def __repr__(self):
20254 
    L = ['%s=%r' % (key, value)
20255 
      for key, value in self.__dict__.iteritems()]
20256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20257 
 
20258 
  def __eq__(self, other):
20259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20260 
 
20261 
  def __ne__(self, other):
20262 
    return not (self == other)
20263 
 
20264 
class getSettlementForPaymentId_result:
20265 
  """
20266 
  Attributes:
20267 
   - success
20268 
   - ex
20269 
  """
20270 
 
20271 
  thrift_spec = (
20272 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20274 
  )
20275 
 
20276 
  def __init__(self, success=None, ex=None,):
20277 
    self.success = success
20278 
    self.ex = ex
20279 
 
20280 
  def read(self, iprot):
20281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20283 
      return
20284 
    iprot.readStructBegin()
20285 
    while True:
20286 
      (fname, ftype, fid) = iprot.readFieldBegin()
20287 
      if ftype == TType.STOP:
20288 
        break
20289 
      if fid == 0:
20290 
        if ftype == TType.STRUCT:
20291 
          self.success = PaymentSettlement()
20292 
          self.success.read(iprot)
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('getSettlementForPaymentId_result')
20311 
    if self.success is not None:
20312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20313 
      self.success.write(oprot)
20314 
      oprot.writeFieldEnd()
20315 
    if self.ex is not None:
20316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20317 
      self.ex.write(oprot)
20318 
      oprot.writeFieldEnd()
20319 
    oprot.writeFieldStop()
20320 
    oprot.writeStructEnd()
20321 
 
20322 
  def validate(self):
20323 
    return
20324 
 
20325 
 
20326 
  def __repr__(self):
20327 
    L = ['%s=%r' % (key, value)
20328 
      for key, value in self.__dict__.iteritems()]
20329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20330 
 
20331 
  def __eq__(self, other):
20332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20333 
 
20334 
  def __ne__(self, other):
20335 
    return not (self == other)
20336 
 
20337 
class getEBSSettlementSummaries_args:
20338 
 
20339 
  thrift_spec = (
20340 
  )
20341 
 
20342 
  def read(self, iprot):
20343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20345 
      return
20346 
    iprot.readStructBegin()
20347 
    while True:
20348 
      (fname, ftype, fid) = iprot.readFieldBegin()
20349 
      if ftype == TType.STOP:
20350 
        break
20351 
      else:
20352 
        iprot.skip(ftype)
20353 
      iprot.readFieldEnd()
20354 
    iprot.readStructEnd()
20355 
 
20356 
  def write(self, oprot):
20357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20359 
      return
20360 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20361 
    oprot.writeFieldStop()
20362 
    oprot.writeStructEnd()
20363 
 
20364 
  def validate(self):
20365 
    return
20366 
 
20367 
 
20368 
  def __repr__(self):
20369 
    L = ['%s=%r' % (key, value)
20370 
      for key, value in self.__dict__.iteritems()]
20371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20372 
 
20373 
  def __eq__(self, other):
20374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20375 
 
20376 
  def __ne__(self, other):
20377 
    return not (self == other)
20378 
 
20379 
class getEBSSettlementSummaries_result:
20380 
  """
20381 
  Attributes:
20382 
   - success
20383 
   - ex
20384 
  """
20385 
 
20386 
  thrift_spec = (
20387 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20389 
  )
20390 
 
20391 
  def __init__(self, success=None, ex=None,):
20392 
    self.success = success
20393 
    self.ex = ex
20394 
 
20395 
  def read(self, iprot):
20396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20398 
      return
20399 
    iprot.readStructBegin()
20400 
    while True:
20401 
      (fname, ftype, fid) = iprot.readFieldBegin()
20402 
      if ftype == TType.STOP:
20403 
        break
20404 
      if fid == 0:
20405 
        if ftype == TType.MAP:
20406 
          self.success = {}
4910 phani.kuma 20407 
          (_ktype428, _vtype429, _size427 ) = iprot.readMapBegin()
20408 
          for _i431 in xrange(_size427):
20409 
            _key432 = iprot.readI64();
20410 
            _val433 = iprot.readString();
20411 
            self.success[_key432] = _val433
4600 varun.gupt 20412 
          iprot.readMapEnd()
20413 
        else:
20414 
          iprot.skip(ftype)
20415 
      elif fid == 1:
20416 
        if ftype == TType.STRUCT:
20417 
          self.ex = TransactionServiceException()
20418 
          self.ex.read(iprot)
20419 
        else:
20420 
          iprot.skip(ftype)
20421 
      else:
20422 
        iprot.skip(ftype)
20423 
      iprot.readFieldEnd()
20424 
    iprot.readStructEnd()
20425 
 
20426 
  def write(self, oprot):
20427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20429 
      return
20430 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20431 
    if self.success is not None:
20432 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20433 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4910 phani.kuma 20434 
      for kiter434,viter435 in self.success.items():
20435 
        oprot.writeI64(kiter434)
20436 
        oprot.writeString(viter435)
4600 varun.gupt 20437 
      oprot.writeMapEnd()
20438 
      oprot.writeFieldEnd()
20439 
    if self.ex is not None:
20440 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20441 
      self.ex.write(oprot)
20442 
      oprot.writeFieldEnd()
20443 
    oprot.writeFieldStop()
20444 
    oprot.writeStructEnd()
20445 
 
20446 
  def validate(self):
20447 
    return
20448 
 
20449 
 
20450 
  def __repr__(self):
20451 
    L = ['%s=%r' % (key, value)
20452 
      for key, value in self.__dict__.iteritems()]
20453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20454 
 
20455 
  def __eq__(self, other):
20456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20457 
 
20458 
  def __ne__(self, other):
20459 
    return not (self == other)
20460 
 
20461 
class markEBSSettlementUploaded_args:
20462 
  """
20463 
  Attributes:
20464 
   - settlementId
20465 
  """
20466 
 
20467 
  thrift_spec = (
20468 
    None, # 0
20469 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20470 
  )
20471 
 
20472 
  def __init__(self, settlementId=None,):
20473 
    self.settlementId = settlementId
20474 
 
20475 
  def read(self, iprot):
20476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20478 
      return
20479 
    iprot.readStructBegin()
20480 
    while True:
20481 
      (fname, ftype, fid) = iprot.readFieldBegin()
20482 
      if ftype == TType.STOP:
20483 
        break
20484 
      if fid == 1:
20485 
        if ftype == TType.I64:
20486 
          self.settlementId = iprot.readI64();
20487 
        else:
20488 
          iprot.skip(ftype)
20489 
      else:
20490 
        iprot.skip(ftype)
20491 
      iprot.readFieldEnd()
20492 
    iprot.readStructEnd()
20493 
 
20494 
  def write(self, oprot):
20495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20497 
      return
20498 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20499 
    if self.settlementId is not None:
20500 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20501 
      oprot.writeI64(self.settlementId)
20502 
      oprot.writeFieldEnd()
20503 
    oprot.writeFieldStop()
20504 
    oprot.writeStructEnd()
20505 
 
20506 
  def validate(self):
20507 
    return
20508 
 
20509 
 
20510 
  def __repr__(self):
20511 
    L = ['%s=%r' % (key, value)
20512 
      for key, value in self.__dict__.iteritems()]
20513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20514 
 
20515 
  def __eq__(self, other):
20516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20517 
 
20518 
  def __ne__(self, other):
20519 
    return not (self == other)
20520 
 
20521 
class markEBSSettlementUploaded_result:
20522 
  """
20523 
  Attributes:
20524 
   - ex
20525 
  """
20526 
 
20527 
  thrift_spec = (
20528 
    None, # 0
20529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20530 
  )
20531 
 
20532 
  def __init__(self, ex=None,):
20533 
    self.ex = ex
20534 
 
20535 
  def read(self, iprot):
20536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20538 
      return
20539 
    iprot.readStructBegin()
20540 
    while True:
20541 
      (fname, ftype, fid) = iprot.readFieldBegin()
20542 
      if ftype == TType.STOP:
20543 
        break
20544 
      if fid == 1:
20545 
        if ftype == TType.STRUCT:
20546 
          self.ex = TransactionServiceException()
20547 
          self.ex.read(iprot)
20548 
        else:
20549 
          iprot.skip(ftype)
20550 
      else:
20551 
        iprot.skip(ftype)
20552 
      iprot.readFieldEnd()
20553 
    iprot.readStructEnd()
20554 
 
20555 
  def write(self, oprot):
20556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20558 
      return
20559 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20560 
    if self.ex is not None:
20561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20562 
      self.ex.write(oprot)
20563 
      oprot.writeFieldEnd()
20564 
    oprot.writeFieldStop()
20565 
    oprot.writeStructEnd()
20566 
 
20567 
  def validate(self):
20568 
    return
20569 
 
20570 
 
20571 
  def __repr__(self):
20572 
    L = ['%s=%r' % (key, value)
20573 
      for key, value in self.__dict__.iteritems()]
20574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20575 
 
20576 
  def __eq__(self, other):
20577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20578 
 
20579 
  def __ne__(self, other):
20580 
    return not (self == other)
20581 
 
20582 
class getEBSSettlementDate_args:
20583 
  """
20584 
  Attributes:
20585 
   - settlementId
20586 
  """
20587 
 
20588 
  thrift_spec = (
20589 
    None, # 0
20590 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20591 
  )
20592 
 
20593 
  def __init__(self, settlementId=None,):
20594 
    self.settlementId = settlementId
20595 
 
20596 
  def read(self, iprot):
20597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20599 
      return
20600 
    iprot.readStructBegin()
20601 
    while True:
20602 
      (fname, ftype, fid) = iprot.readFieldBegin()
20603 
      if ftype == TType.STOP:
20604 
        break
20605 
      if fid == 1:
20606 
        if ftype == TType.I64:
20607 
          self.settlementId = iprot.readI64();
20608 
        else:
20609 
          iprot.skip(ftype)
20610 
      else:
20611 
        iprot.skip(ftype)
20612 
      iprot.readFieldEnd()
20613 
    iprot.readStructEnd()
20614 
 
20615 
  def write(self, oprot):
20616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20618 
      return
20619 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20620 
    if self.settlementId is not None:
20621 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20622 
      oprot.writeI64(self.settlementId)
20623 
      oprot.writeFieldEnd()
20624 
    oprot.writeFieldStop()
20625 
    oprot.writeStructEnd()
20626 
 
20627 
  def validate(self):
20628 
    return
20629 
 
20630 
 
20631 
  def __repr__(self):
20632 
    L = ['%s=%r' % (key, value)
20633 
      for key, value in self.__dict__.iteritems()]
20634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20635 
 
20636 
  def __eq__(self, other):
20637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20638 
 
20639 
  def __ne__(self, other):
20640 
    return not (self == other)
20641 
 
20642 
class getEBSSettlementDate_result:
20643 
  """
20644 
  Attributes:
20645 
   - success
20646 
   - ex
20647 
  """
20648 
 
20649 
  thrift_spec = (
20650 
    (0, TType.I64, 'success', None, None, ), # 0
20651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20652 
  )
20653 
 
20654 
  def __init__(self, success=None, ex=None,):
20655 
    self.success = success
20656 
    self.ex = ex
20657 
 
20658 
  def read(self, iprot):
20659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20661 
      return
20662 
    iprot.readStructBegin()
20663 
    while True:
20664 
      (fname, ftype, fid) = iprot.readFieldBegin()
20665 
      if ftype == TType.STOP:
20666 
        break
20667 
      if fid == 0:
20668 
        if ftype == TType.I64:
20669 
          self.success = iprot.readI64();
20670 
        else:
20671 
          iprot.skip(ftype)
20672 
      elif fid == 1:
20673 
        if ftype == TType.STRUCT:
20674 
          self.ex = TransactionServiceException()
20675 
          self.ex.read(iprot)
20676 
        else:
20677 
          iprot.skip(ftype)
20678 
      else:
20679 
        iprot.skip(ftype)
20680 
      iprot.readFieldEnd()
20681 
    iprot.readStructEnd()
20682 
 
20683 
  def write(self, oprot):
20684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20686 
      return
20687 
    oprot.writeStructBegin('getEBSSettlementDate_result')
20688 
    if self.success is not None:
20689 
      oprot.writeFieldBegin('success', TType.I64, 0)
20690 
      oprot.writeI64(self.success)
20691 
      oprot.writeFieldEnd()
20692 
    if self.ex is not None:
20693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20694 
      self.ex.write(oprot)
20695 
      oprot.writeFieldEnd()
20696 
    oprot.writeFieldStop()
20697 
    oprot.writeStructEnd()
20698 
 
20699 
  def validate(self):
20700 
    return
20701 
 
20702 
 
20703 
  def __repr__(self):
20704 
    L = ['%s=%r' % (key, value)
20705 
      for key, value in self.__dict__.iteritems()]
20706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20707 
 
20708 
  def __eq__(self, other):
20709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20710 
 
20711 
  def __ne__(self, other):
20712 
    return not (self == other)
4715 varun.gupt 20713 
 
20714 
class getSettlementsByDate_args:
20715 
  """
20716 
  Attributes:
20717 
   - settlementDateFrom
20718 
   - settlementDateTo
20719 
   - isRefund
20720 
  """
20721 
 
20722 
  thrift_spec = (
20723 
    None, # 0
20724 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
20725 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
20726 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
20727 
  )
20728 
 
20729 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
20730 
    self.settlementDateFrom = settlementDateFrom
20731 
    self.settlementDateTo = settlementDateTo
20732 
    self.isRefund = isRefund
20733 
 
20734 
  def read(self, iprot):
20735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20737 
      return
20738 
    iprot.readStructBegin()
20739 
    while True:
20740 
      (fname, ftype, fid) = iprot.readFieldBegin()
20741 
      if ftype == TType.STOP:
20742 
        break
20743 
      if fid == 1:
20744 
        if ftype == TType.I64:
20745 
          self.settlementDateFrom = iprot.readI64();
20746 
        else:
20747 
          iprot.skip(ftype)
20748 
      elif fid == 2:
20749 
        if ftype == TType.I64:
20750 
          self.settlementDateTo = iprot.readI64();
20751 
        else:
20752 
          iprot.skip(ftype)
20753 
      elif fid == 3:
20754 
        if ftype == TType.BOOL:
20755 
          self.isRefund = iprot.readBool();
20756 
        else:
20757 
          iprot.skip(ftype)
20758 
      else:
20759 
        iprot.skip(ftype)
20760 
      iprot.readFieldEnd()
20761 
    iprot.readStructEnd()
20762 
 
20763 
  def write(self, oprot):
20764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20766 
      return
20767 
    oprot.writeStructBegin('getSettlementsByDate_args')
20768 
    if self.settlementDateFrom is not None:
20769 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
20770 
      oprot.writeI64(self.settlementDateFrom)
20771 
      oprot.writeFieldEnd()
20772 
    if self.settlementDateTo is not None:
20773 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
20774 
      oprot.writeI64(self.settlementDateTo)
20775 
      oprot.writeFieldEnd()
20776 
    if self.isRefund is not None:
20777 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
20778 
      oprot.writeBool(self.isRefund)
20779 
      oprot.writeFieldEnd()
20780 
    oprot.writeFieldStop()
20781 
    oprot.writeStructEnd()
20782 
 
20783 
  def validate(self):
20784 
    return
20785 
 
20786 
 
20787 
  def __repr__(self):
20788 
    L = ['%s=%r' % (key, value)
20789 
      for key, value in self.__dict__.iteritems()]
20790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20791 
 
20792 
  def __eq__(self, other):
20793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20794 
 
20795 
  def __ne__(self, other):
20796 
    return not (self == other)
20797 
 
20798 
class getSettlementsByDate_result:
20799 
  """
20800 
  Attributes:
20801 
   - success
20802 
   - ex
20803 
  """
20804 
 
20805 
  thrift_spec = (
20806 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
20807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20808 
  )
20809 
 
20810 
  def __init__(self, success=None, ex=None,):
20811 
    self.success = success
20812 
    self.ex = ex
20813 
 
20814 
  def read(self, iprot):
20815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20817 
      return
20818 
    iprot.readStructBegin()
20819 
    while True:
20820 
      (fname, ftype, fid) = iprot.readFieldBegin()
20821 
      if ftype == TType.STOP:
20822 
        break
20823 
      if fid == 0:
20824 
        if ftype == TType.LIST:
20825 
          self.success = []
4910 phani.kuma 20826 
          (_etype439, _size436) = iprot.readListBegin()
20827 
          for _i440 in xrange(_size436):
20828 
            _elem441 = PaymentSettlement()
20829 
            _elem441.read(iprot)
20830 
            self.success.append(_elem441)
4715 varun.gupt 20831 
          iprot.readListEnd()
20832 
        else:
20833 
          iprot.skip(ftype)
20834 
      elif fid == 1:
20835 
        if ftype == TType.STRUCT:
20836 
          self.ex = TransactionServiceException()
20837 
          self.ex.read(iprot)
20838 
        else:
20839 
          iprot.skip(ftype)
20840 
      else:
20841 
        iprot.skip(ftype)
20842 
      iprot.readFieldEnd()
20843 
    iprot.readStructEnd()
20844 
 
20845 
  def write(self, oprot):
20846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20848 
      return
20849 
    oprot.writeStructBegin('getSettlementsByDate_result')
20850 
    if self.success is not None:
20851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 20853 
      for iter442 in self.success:
20854 
        iter442.write(oprot)
4715 varun.gupt 20855 
      oprot.writeListEnd()
20856 
      oprot.writeFieldEnd()
20857 
    if self.ex is not None:
20858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20859 
      self.ex.write(oprot)
20860 
      oprot.writeFieldEnd()
20861 
    oprot.writeFieldStop()
20862 
    oprot.writeStructEnd()
20863 
 
20864 
  def validate(self):
20865 
    return
20866 
 
20867 
 
20868 
  def __repr__(self):
20869 
    L = ['%s=%r' % (key, value)
20870 
      for key, value in self.__dict__.iteritems()]
20871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20872 
 
20873 
  def __eq__(self, other):
20874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20875 
 
20876 
  def __ne__(self, other):
20877 
    return not (self == other)
20878 
 
20879 
class getReshippedOrderIds_args:
20880 
  """
20881 
  Attributes:
20882 
   - orderIds
20883 
  """
20884 
 
20885 
  thrift_spec = (
20886 
    None, # 0
20887 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
20888 
  )
20889 
 
20890 
  def __init__(self, orderIds=None,):
20891 
    self.orderIds = orderIds
20892 
 
20893 
  def read(self, iprot):
20894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20896 
      return
20897 
    iprot.readStructBegin()
20898 
    while True:
20899 
      (fname, ftype, fid) = iprot.readFieldBegin()
20900 
      if ftype == TType.STOP:
20901 
        break
20902 
      if fid == 1:
20903 
        if ftype == TType.LIST:
20904 
          self.orderIds = []
4910 phani.kuma 20905 
          (_etype446, _size443) = iprot.readListBegin()
20906 
          for _i447 in xrange(_size443):
20907 
            _elem448 = iprot.readI64();
20908 
            self.orderIds.append(_elem448)
4715 varun.gupt 20909 
          iprot.readListEnd()
20910 
        else:
20911 
          iprot.skip(ftype)
20912 
      else:
20913 
        iprot.skip(ftype)
20914 
      iprot.readFieldEnd()
20915 
    iprot.readStructEnd()
20916 
 
20917 
  def write(self, oprot):
20918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20920 
      return
20921 
    oprot.writeStructBegin('getReshippedOrderIds_args')
20922 
    if self.orderIds is not None:
20923 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
20924 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4910 phani.kuma 20925 
      for iter449 in self.orderIds:
20926 
        oprot.writeI64(iter449)
4715 varun.gupt 20927 
      oprot.writeListEnd()
20928 
      oprot.writeFieldEnd()
20929 
    oprot.writeFieldStop()
20930 
    oprot.writeStructEnd()
20931 
 
20932 
  def validate(self):
20933 
    return
20934 
 
20935 
 
20936 
  def __repr__(self):
20937 
    L = ['%s=%r' % (key, value)
20938 
      for key, value in self.__dict__.iteritems()]
20939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20940 
 
20941 
  def __eq__(self, other):
20942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20943 
 
20944 
  def __ne__(self, other):
20945 
    return not (self == other)
20946 
 
20947 
class getReshippedOrderIds_result:
20948 
  """
20949 
  Attributes:
20950 
   - success
20951 
   - ex
20952 
  """
20953 
 
20954 
  thrift_spec = (
20955 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20957 
  )
20958 
 
20959 
  def __init__(self, success=None, ex=None,):
20960 
    self.success = success
20961 
    self.ex = ex
20962 
 
20963 
  def read(self, iprot):
20964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20966 
      return
20967 
    iprot.readStructBegin()
20968 
    while True:
20969 
      (fname, ftype, fid) = iprot.readFieldBegin()
20970 
      if ftype == TType.STOP:
20971 
        break
20972 
      if fid == 0:
20973 
        if ftype == TType.LIST:
20974 
          self.success = []
4910 phani.kuma 20975 
          (_etype453, _size450) = iprot.readListBegin()
20976 
          for _i454 in xrange(_size450):
20977 
            _elem455 = iprot.readI64();
20978 
            self.success.append(_elem455)
4715 varun.gupt 20979 
          iprot.readListEnd()
20980 
        else:
20981 
          iprot.skip(ftype)
20982 
      elif fid == 1:
20983 
        if ftype == TType.STRUCT:
20984 
          self.ex = TransactionServiceException()
20985 
          self.ex.read(iprot)
20986 
        else:
20987 
          iprot.skip(ftype)
20988 
      else:
20989 
        iprot.skip(ftype)
20990 
      iprot.readFieldEnd()
20991 
    iprot.readStructEnd()
20992 
 
20993 
  def write(self, oprot):
20994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20996 
      return
20997 
    oprot.writeStructBegin('getReshippedOrderIds_result')
20998 
    if self.success is not None:
20999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21000 
      oprot.writeListBegin(TType.I64, len(self.success))
4910 phani.kuma 21001 
      for iter456 in self.success:
21002 
        oprot.writeI64(iter456)
4715 varun.gupt 21003 
      oprot.writeListEnd()
21004 
      oprot.writeFieldEnd()
21005 
    if self.ex is not None:
21006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21007 
      self.ex.write(oprot)
21008 
      oprot.writeFieldEnd()
21009 
    oprot.writeFieldStop()
21010 
    oprot.writeStructEnd()
21011 
 
21012 
  def validate(self):
21013 
    return
21014 
 
21015 
 
21016 
  def __repr__(self):
21017 
    L = ['%s=%r' % (key, value)
21018 
      for key, value in self.__dict__.iteritems()]
21019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21020 
 
21021 
  def __eq__(self, other):
21022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21023 
 
21024 
  def __ne__(self, other):
21025 
    return not (self == other)
4757 mandeep.dh 21026 
 
21027 
class updateOrdersAsPORaised_args:
21028 
  """
21029 
  Attributes:
21030 
   - itemIdQuantityMap
21031 
   - purchaseOrderId
21032 
   - warehouseId
21033 
  """
21034 
 
21035 
  thrift_spec = (
21036 
    None, # 0
21037 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21038 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21039 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21040 
  )
21041 
 
21042 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21043 
    self.itemIdQuantityMap = itemIdQuantityMap
21044 
    self.purchaseOrderId = purchaseOrderId
21045 
    self.warehouseId = warehouseId
21046 
 
21047 
  def read(self, iprot):
21048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21050 
      return
21051 
    iprot.readStructBegin()
21052 
    while True:
21053 
      (fname, ftype, fid) = iprot.readFieldBegin()
21054 
      if ftype == TType.STOP:
21055 
        break
21056 
      if fid == 1:
21057 
        if ftype == TType.MAP:
21058 
          self.itemIdQuantityMap = {}
4910 phani.kuma 21059 
          (_ktype458, _vtype459, _size457 ) = iprot.readMapBegin()
21060 
          for _i461 in xrange(_size457):
21061 
            _key462 = iprot.readI64();
21062 
            _val463 = iprot.readI64();
21063 
            self.itemIdQuantityMap[_key462] = _val463
4757 mandeep.dh 21064 
          iprot.readMapEnd()
21065 
        else:
21066 
          iprot.skip(ftype)
21067 
      elif fid == 2:
21068 
        if ftype == TType.I64:
21069 
          self.purchaseOrderId = iprot.readI64();
21070 
        else:
21071 
          iprot.skip(ftype)
21072 
      elif fid == 3:
21073 
        if ftype == TType.I64:
21074 
          self.warehouseId = iprot.readI64();
21075 
        else:
21076 
          iprot.skip(ftype)
21077 
      else:
21078 
        iprot.skip(ftype)
21079 
      iprot.readFieldEnd()
21080 
    iprot.readStructEnd()
21081 
 
21082 
  def write(self, oprot):
21083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21085 
      return
21086 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21087 
    if self.itemIdQuantityMap is not None:
21088 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21089 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4910 phani.kuma 21090 
      for kiter464,viter465 in self.itemIdQuantityMap.items():
21091 
        oprot.writeI64(kiter464)
21092 
        oprot.writeI64(viter465)
4757 mandeep.dh 21093 
      oprot.writeMapEnd()
21094 
      oprot.writeFieldEnd()
21095 
    if self.purchaseOrderId is not None:
21096 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21097 
      oprot.writeI64(self.purchaseOrderId)
21098 
      oprot.writeFieldEnd()
21099 
    if self.warehouseId is not None:
21100 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21101 
      oprot.writeI64(self.warehouseId)
21102 
      oprot.writeFieldEnd()
21103 
    oprot.writeFieldStop()
21104 
    oprot.writeStructEnd()
21105 
 
21106 
  def validate(self):
21107 
    return
21108 
 
21109 
 
21110 
  def __repr__(self):
21111 
    L = ['%s=%r' % (key, value)
21112 
      for key, value in self.__dict__.iteritems()]
21113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21114 
 
21115 
  def __eq__(self, other):
21116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21117 
 
21118 
  def __ne__(self, other):
21119 
    return not (self == other)
21120 
 
21121 
class updateOrdersAsPORaised_result:
21122 
  """
21123 
  Attributes:
21124 
   - ex
21125 
  """
21126 
 
21127 
  thrift_spec = (
21128 
    None, # 0
21129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21130 
  )
21131 
 
21132 
  def __init__(self, ex=None,):
21133 
    self.ex = ex
21134 
 
21135 
  def read(self, iprot):
21136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21138 
      return
21139 
    iprot.readStructBegin()
21140 
    while True:
21141 
      (fname, ftype, fid) = iprot.readFieldBegin()
21142 
      if ftype == TType.STOP:
21143 
        break
21144 
      if fid == 1:
21145 
        if ftype == TType.STRUCT:
21146 
          self.ex = TransactionServiceException()
21147 
          self.ex.read(iprot)
21148 
        else:
21149 
          iprot.skip(ftype)
21150 
      else:
21151 
        iprot.skip(ftype)
21152 
      iprot.readFieldEnd()
21153 
    iprot.readStructEnd()
21154 
 
21155 
  def write(self, oprot):
21156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21158 
      return
21159 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21160 
    if self.ex is not None:
21161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21162 
      self.ex.write(oprot)
21163 
      oprot.writeFieldEnd()
21164 
    oprot.writeFieldStop()
21165 
    oprot.writeStructEnd()
21166 
 
21167 
  def validate(self):
21168 
    return
21169 
 
21170 
 
21171 
  def __repr__(self):
21172 
    L = ['%s=%r' % (key, value)
21173 
      for key, value in self.__dict__.iteritems()]
21174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21175 
 
21176 
  def __eq__(self, other):
21177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21178 
 
21179 
  def __ne__(self, other):
21180 
    return not (self == other)
4875 varun.gupt 21181 
 
21182 
class getOrdersWhereVendorNotPaid_args:
21183 
  """
21184 
  Attributes:
21185 
   - vendorId
21186 
  """
21187 
 
21188 
  thrift_spec = (
21189 
    None, # 0
21190 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21191 
  )
21192 
 
21193 
  def __init__(self, vendorId=None,):
21194 
    self.vendorId = vendorId
21195 
 
21196 
  def read(self, iprot):
21197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21199 
      return
21200 
    iprot.readStructBegin()
21201 
    while True:
21202 
      (fname, ftype, fid) = iprot.readFieldBegin()
21203 
      if ftype == TType.STOP:
21204 
        break
21205 
      if fid == 1:
21206 
        if ftype == TType.I64:
21207 
          self.vendorId = iprot.readI64();
21208 
        else:
21209 
          iprot.skip(ftype)
21210 
      else:
21211 
        iprot.skip(ftype)
21212 
      iprot.readFieldEnd()
21213 
    iprot.readStructEnd()
21214 
 
21215 
  def write(self, oprot):
21216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21218 
      return
21219 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21220 
    if self.vendorId is not None:
21221 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21222 
      oprot.writeI64(self.vendorId)
21223 
      oprot.writeFieldEnd()
21224 
    oprot.writeFieldStop()
21225 
    oprot.writeStructEnd()
21226 
 
21227 
  def validate(self):
21228 
    return
21229 
 
21230 
 
21231 
  def __repr__(self):
21232 
    L = ['%s=%r' % (key, value)
21233 
      for key, value in self.__dict__.iteritems()]
21234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21235 
 
21236 
  def __eq__(self, other):
21237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21238 
 
21239 
  def __ne__(self, other):
21240 
    return not (self == other)
21241 
 
21242 
class getOrdersWhereVendorNotPaid_result:
21243 
  """
21244 
  Attributes:
21245 
   - success
21246 
   - ex
21247 
  """
21248 
 
21249 
  thrift_spec = (
21250 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21252 
  )
21253 
 
21254 
  def __init__(self, success=None, ex=None,):
21255 
    self.success = success
21256 
    self.ex = ex
21257 
 
21258 
  def read(self, iprot):
21259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21261 
      return
21262 
    iprot.readStructBegin()
21263 
    while True:
21264 
      (fname, ftype, fid) = iprot.readFieldBegin()
21265 
      if ftype == TType.STOP:
21266 
        break
21267 
      if fid == 0:
21268 
        if ftype == TType.LIST:
21269 
          self.success = []
4910 phani.kuma 21270 
          (_etype469, _size466) = iprot.readListBegin()
21271 
          for _i470 in xrange(_size466):
21272 
            _elem471 = Order()
21273 
            _elem471.read(iprot)
21274 
            self.success.append(_elem471)
4875 varun.gupt 21275 
          iprot.readListEnd()
21276 
        else:
21277 
          iprot.skip(ftype)
21278 
      elif fid == 1:
21279 
        if ftype == TType.STRUCT:
21280 
          self.ex = TransactionServiceException()
21281 
          self.ex.read(iprot)
21282 
        else:
21283 
          iprot.skip(ftype)
21284 
      else:
21285 
        iprot.skip(ftype)
21286 
      iprot.readFieldEnd()
21287 
    iprot.readStructEnd()
21288 
 
21289 
  def write(self, oprot):
21290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21292 
      return
21293 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21294 
    if self.success is not None:
21295 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21296 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4910 phani.kuma 21297 
      for iter472 in self.success:
21298 
        iter472.write(oprot)
4875 varun.gupt 21299 
      oprot.writeListEnd()
21300 
      oprot.writeFieldEnd()
21301 
    if self.ex is not None:
21302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21303 
      self.ex.write(oprot)
21304 
      oprot.writeFieldEnd()
21305 
    oprot.writeFieldStop()
21306 
    oprot.writeStructEnd()
21307 
 
21308 
  def validate(self):
21309 
    return
21310 
 
21311 
 
21312 
  def __repr__(self):
21313 
    L = ['%s=%r' % (key, value)
21314 
      for key, value in self.__dict__.iteritems()]
21315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21316 
 
21317 
  def __eq__(self, other):
21318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21319 
 
21320 
  def __ne__(self, other):
21321 
    return not (self == other)