Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
4999 phani.kuma 208 
  def getOrderList(self, order_ids):
209 
    """
210 
    Parameters:
211 
     - order_ids
212 
    """
213 
    pass
214 
 
1528 ankur.sing 215 
  def getOrderForCustomer(self, orderId, customerId):
216 
    """
217 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
218 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 219 
 
1528 ankur.sing 220 
    Parameters:
221 
     - orderId
222 
     - customerId
223 
    """
224 
    pass
225 
 
4444 rajveer 226 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 227 
    """
228 
    Parameters:
4394 rajveer 229 
     - type
4444 rajveer 230 
     - warehouseId
4394 rajveer 231 
     - status
232 
     - timestamp
3064 chandransh 233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 237 
    """
238 
    Parameters:
239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - description
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def markAlertsAsSeen(self, warehouseId):
246 
    """
247 
    Parameters:
248 
     - warehouseId
249 
    """
250 
    pass
251 
 
3064 chandransh 252 
  def getValidOrderCount(self, ):
253 
    """
254 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
255 
    """
256 
    pass
257 
 
258 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
259 
    """
260 
    Returns the number of distinct customers who have done successful transactions
261 
    """
262 
    pass
263 
 
264 
  def getValidOrdersAmountRange(self, ):
265 
    """
266 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
267 
    List contains two values, first minimum amount and second maximum amount.
268 
    """
269 
    pass
270 
 
271 
  def getValidOrders(self, limit):
272 
    """
273 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
274 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 275 
 
3064 chandransh 276 
    Parameters:
277 
     - limit
278 
    """
279 
    pass
280 
 
1220 chandransh 281 
  def batchOrders(self, warehouseId):
282 
    """
283 
    Create a batch of all the pending orders for the given warehouse.
284 
    The returned list is orderd by created_timestamp.
285 
    If there are no pending orders, an empty list is returned.
3431 rajveer 286 
 
1220 chandransh 287 
    Parameters:
288 
     - warehouseId
289 
    """
290 
    pass
291 
 
1208 chandransh 292 
  def markOrderAsOutOfStock(self, orderId):
293 
    """
294 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 295 
 
1208 chandransh 296 
    Parameters:
297 
     - orderId
298 
    """
299 
    pass
300 
 
3064 chandransh 301 
  def verifyOrder(self, orderId):
759 chandransh 302 
    """
3064 chandransh 303 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
304 
    timestamp. It is intended to be used for COD orders but can be harmlessly
305 
    used for all other orders as well.
306 
    Throws an exception if no such order exists.
3431 rajveer 307 
 
759 chandransh 308 
    Parameters:
3064 chandransh 309 
     - orderId
310 
    """
311 
    pass
312 
 
313 
  def acceptOrder(self, orderId):
314 
    """
315 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
316 
    given order is not a COD order, it also captures the payment if the same has
317 
    not been captured.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
3064 chandransh 320 
    Parameters:
321 
     - orderId
322 
    """
323 
    pass
324 
 
4763 rajveer 325 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 326 
    """
327 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 328 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 329 
    the IMEI no. if a -1 is supplied.
330 
    Also, it generates an invoice number for the order, marks the order as
331 
    BILLED and sets the billing timestamp.
332 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 333 
 
3064 chandransh 334 
    Parameters:
335 
     - orderId
4283 anupam.sin 336 
     - invoice_number
4658 mandeep.dh 337 
     - serialNumber
3064 chandransh 338 
     - itemNumber
4283 anupam.sin 339 
     - billed_by
340 
     - jacketNumber
3064 chandransh 341 
     - billingType
4283 anupam.sin 342 
     - vendorId
4763 rajveer 343 
     - authorize
3064 chandransh 344 
    """
345 
    pass
346 
 
4763 rajveer 347 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 348 
    """
349 
    Add the invoice number to the order.
350 
 
351 
    Parameters:
352 
     - orderId
353 
     - invoiceNumber
4763 rajveer 354 
     - color
4579 rajveer 355 
    """
356 
    pass
357 
 
4910 phani.kuma 358 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 359 
    """
360 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 361 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 362 
 
363 
    Parameters:
364 
     - warehouseId
365 
     - providerId
366 
     - cod
4910 phani.kuma 367 
     - orderIds
4410 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 372 
    """
4910 phani.kuma 373 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
374 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 375 
 
3064 chandransh 376 
    Parameters:
759 chandransh 377 
     - providerId
4910 phani.kuma 378 
     - pickupDetails
759 chandransh 379 
    """
380 
    pass
381 
 
4910 phani.kuma 382 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 383 
    """
384 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 385 
 
1113 chandransh 386 
    Parameters:
387 
     - providerId
388 
    """
389 
    pass
390 
 
1132 chandransh 391 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
392 
    """
393 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
394 
    the name of the receiver.
395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 396 
 
1132 chandransh 397 
    Parameters:
398 
     - providerId
399 
     - deliveredOrders
400 
    """
401 
    pass
402 
 
4910 phani.kuma 403 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 404 
    """
4910 phani.kuma 405 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 406 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 407 
 
1135 chandransh 408 
    Parameters:
409 
     - providerId
410 
     - returnedOrders
411 
    """
412 
    pass
413 
 
4910 phani.kuma 414 
  def getRTOrders(self, providerId):
415 
    """
416 
    Returns a list of orders that were returned by courier.
417 
 
418 
    Parameters:
419 
     - providerId
420 
    """
421 
    pass
422 
 
1246 chandransh 423 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
424 
    """
425 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 426 
 
1246 chandransh 427 
    Parameters:
428 
     - providerId
429 
     - undeliveredOrders
430 
    """
431 
    pass
432 
 
4910 phani.kuma 433 
  def getNonDeliveredOrdersbyCourier(self, providerId):
434 
    """
435 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
436 
 
437 
    Parameters:
438 
     - providerId
439 
    """
440 
    pass
441 
 
442 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
443 
    """
444 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
445 
 
446 
    Parameters:
447 
     - providerId
448 
     - local_connected_orders
449 
    """
450 
    pass
451 
 
452 
  def getOrdersNotLocalConnected(self, providerId):
453 
    """
454 
    Returns a list of orders that were picked up or shipped but pending local connection.
455 
 
456 
    Parameters:
457 
     - providerId
458 
    """
459 
    pass
460 
 
461 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
462 
    """
463 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
464 
 
465 
    Parameters:
466 
     - providerId
467 
     - destination_city_reached_orders
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - first_atdl_orders
478 
    """
479 
    pass
480 
 
1408 ankur.sing 481 
  def getUndeliveredOrders(self, providerId, warehouseId):
482 
    """
483 
    Returns the list of orders whose delivery time has passed but have not been
484 
    delivered yet for the given provider and warehouse. To get a complete list of
485 
    undelivered orders, pass them as -1.
486 
    Returns an empty list if no such orders exist.
3431 rajveer 487 
 
1408 ankur.sing 488 
    Parameters:
489 
     - providerId
490 
     - warehouseId
491 
    """
492 
    pass
493 
 
4783 phani.kuma 494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
495 
    """
496 
    Returns the list of orders whose expected delivery date has passed but have not been
497 
    delivered yet.
498 
    Returns an empty list if no such orders exist.
499 
    """
500 
    pass
501 
 
2536 chandransh 502 
  def toggleDOAFlag(self, orderId):
503 
    """
504 
    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.
505 
    Returns the final flag status.
506 
    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 507 
 
2536 chandransh 508 
    Parameters:
509 
     - orderId
510 
    """
511 
    pass
1886 ankur.sing 512 
 
4712 rajveer 513 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
514 
    """
515 
    Parameters:
516 
     - orderId
517 
     - deliveryTimestamp
518 
     - receiver
519 
    """
520 
    pass
521 
 
4454 rajveer 522 
  def markOrderDoaRequestReceived(self, orderId):
523 
    """
524 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
525 
 
526 
    Parameters:
527 
     - orderId
528 
    """
529 
    pass
530 
 
531 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
532 
    """
533 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
534 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
535 
 
536 
    Parameters:
537 
     - orderId
538 
     - isAuthorized
539 
    """
540 
    pass
541 
 
4488 rajveer 542 
  def markOrderReturnRequestReceived(self, orderId):
543 
    """
544 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
545 
 
546 
    Parameters:
547 
     - orderId
548 
    """
549 
    pass
550 
 
551 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
552 
    """
553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
554 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
555 
 
556 
    Parameters:
557 
     - orderId
558 
     - isAuthorized
559 
    """
560 
    pass
561 
 
4579 rajveer 562 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 563 
    """
564 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 565 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
566 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 567 
    For any other status, it returns false.
568 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 569 
 
2536 chandransh 570 
    Parameters:
571 
     - orderId
4579 rajveer 572 
     - providerId
2536 chandransh 573 
    """
574 
    pass
575 
 
4602 rajveer 576 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 577 
    """
4452 rajveer 578 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 579 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
580 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
581 
    	3. Returns true
2591 chandransh 582 
    If the order is in any other status, it returns false.
2536 chandransh 583 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 584 
 
2536 chandransh 585 
    Parameters:
586 
     - orderId
587 
     - pickupNumber
4602 rajveer 588 
     - providerId
2536 chandransh 589 
    """
590 
    pass
591 
 
2764 chandransh 592 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
593 
    """
594 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 595 
 
2764 chandransh 596 
    Parameters:
597 
     - providerId
598 
     - pickupDetails
599 
    """
600 
    pass
601 
 
4910 phani.kuma 602 
  def getDoasNotPickedUp(self, providerId):
603 
    """
604 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
605 
 
606 
    Parameters:
607 
     - providerId
608 
    """
609 
    pass
610 
 
4741 phani.kuma 611 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
612 
    """
613 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
614 
 
615 
    Parameters:
616 
     - providerId
617 
     - pickupDetails
618 
    """
619 
    pass
620 
 
4910 phani.kuma 621 
  def getReturnOrdersNotPickedUp(self, providerId):
622 
    """
623 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
624 
 
625 
    Parameters:
626 
     - providerId
627 
    """
628 
    pass
629 
 
4479 rajveer 630 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 631 
    """
4452 rajveer 632 
    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 633 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 634 
    If the order is in any other state, it returns false.
635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 636 
 
2591 chandransh 637 
    Parameters:
638 
     - orderId
4479 rajveer 639 
     - receiveCondition
2591 chandransh 640 
    """
641 
    pass
2536 chandransh 642 
 
2591 chandransh 643 
  def validateDoa(self, orderId, isValid):
644 
    """
4452 rajveer 645 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 646 
    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 647 
    If the order is in any other state, it returns false.
648 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 649 
 
2591 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - isValid
653 
    """
654 
    pass
655 
 
4495 rajveer 656 
  def validateReturnProduct(self, orderId, isUsable):
657 
    """
658 
    Parameters:
659 
     - orderId
660 
     - isUsable
661 
    """
662 
    pass
663 
 
2616 chandransh 664 
  def reshipOrder(self, orderId):
665 
    """
4484 rajveer 666 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 667 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 668 
    	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 669 
 
670 
    If the order is in DOA_CERT_VALID state, it does the following:
671 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
672 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 673 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 674 
 
2616 chandransh 675 
    Returns the id of the newly created order.
3431 rajveer 676 
 
2616 chandransh 677 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 678 
 
2616 chandransh 679 
    Parameters:
680 
     - orderId
681 
    """
682 
    pass
2591 chandransh 683 
 
3226 chandransh 684 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 685 
    """
4484 rajveer 686 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 687 
    	1. Creates a refund request for batch processing.
688 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 689 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 690 
 
2616 chandransh 691 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
692 
    	1. Creates a refund request for batch processing.
3226 chandransh 693 
    	2. Cancels the reservation of the item in the warehouse.
694 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 695 
 
3226 chandransh 696 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
697 
    	1. Cancels the reservation of the item in the warehouse.
698 
    	2. Marks the current order as CANCELED.
699 
 
700 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
701 
 
2616 chandransh 702 
    Returns True if it is successful, False otherwise.
3431 rajveer 703 
 
2616 chandransh 704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 705 
 
2616 chandransh 706 
    Parameters:
707 
     - orderId
3226 chandransh 708 
     - refundedBy
709 
     - reason
2616 chandransh 710 
    """
711 
    pass
712 
 
2690 chandransh 713 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
714 
    """
715 
    Get all return orders created between the from and to dates for the given warehouse.
716 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 717 
 
2690 chandransh 718 
    Parameters:
719 
     - warehouseId
720 
     - fromDate
721 
     - toDate
722 
    """
723 
    pass
2616 chandransh 724 
 
2700 chandransh 725 
  def getReturnOrder(self, id):
726 
    """
727 
    Returns the ReturnOrder corresponding to the given id.
728 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 729 
 
2700 chandransh 730 
    Parameters:
731 
     - id
732 
    """
733 
    pass
734 
 
2690 chandransh 735 
  def processReturn(self, returnOrderId):
736 
    """
737 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 738 
 
2690 chandransh 739 
    Parameters:
740 
     - returnOrderId
741 
    """
742 
    pass
743 
 
3451 chandransh 744 
  def updateWeight(self, orderId, weight):
745 
    """
746 
    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 747 
 
3451 chandransh 748 
    Parameters:
749 
     - orderId
750 
     - weight
751 
    """
752 
    pass
753 
 
3469 chandransh 754 
  def changeItem(self, orderId, itemId):
755 
    """
756 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
757 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 758 
 
3469 chandransh 759 
    Parameters:
760 
     - orderId
761 
     - itemId
762 
    """
763 
    pass
764 
 
765 
  def shiftToWarehouse(self, orderId, warehouseId):
766 
    """
767 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
768 
 
769 
    Parameters:
770 
     - orderId
771 
     - warehouseId
772 
    """
773 
    pass
774 
 
4647 rajveer 775 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 776 
    """
777 
    Adds the given delay reason to the given order.
3986 chandransh 778 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 779 
    Raises an exception if no order with the given id can be found.
3469 chandransh 780 
 
3553 chandransh 781 
    Parameters:
782 
     - orderId
783 
     - delayReason
3986 chandransh 784 
     - furtherDelay
4647 rajveer 785 
     - delayReasonText
3553 chandransh 786 
    """
787 
    pass
788 
 
3956 chandransh 789 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
790 
    """
791 
    Marks the COD orders with given AWB nos. as having been processed.
792 
    Updates the captured amount for the corresponding payment.
3553 chandransh 793 
 
3956 chandransh 794 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
795 
    1. There is no order corresponding to an AWB number.
796 
    2. The captured amount for a payment exceeds the total payment.
797 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
798 
 
799 
    Parameters:
800 
     - collectedAmountMap
801 
     - xferBy
802 
     - xferTxnId
803 
     - xferDate
804 
    """
805 
    pass
806 
 
4008 mandeep.dh 807 
  def getTransactionsRequiringExtraProcessing(self, category):
808 
    """
4065 mandeep.dh 809 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 810 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 811 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 812 
 
4008 mandeep.dh 813 
    Parameters:
814 
     - category
815 
    """
816 
    pass
817 
 
818 
  def markTransactionAsProcessed(self, transactionId, category):
819 
    """
820 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 821 
    It essentially deletes the transaction id record for a particular
822 
    processing type category (if present) from DB.
823 
    This is currently used by CRM application.
4008 mandeep.dh 824 
 
825 
    Parameters:
826 
     - transactionId
827 
     - category
828 
    """
829 
    pass
830 
 
4018 chandransh 831 
  def getItemWiseRiskyOrdersCount(self, ):
832 
    """
833 
    Returns a map containing the number of risky orders keyed by item id. A risky order
834 
    is defined as one whose shipping date is about to expire.
835 
    """
836 
    pass
4008 mandeep.dh 837 
 
4295 varun.gupt 838 
  def getOrdersForItemIds(self, itemIds):
839 
    """
840 
    Returns a list of all orders which have items with given id
841 
 
842 
    Parameters:
843 
     - itemIds
844 
    """
845 
    pass
846 
 
4247 rajveer 847 
  def markOrderCancellationRequestReceived(self, orderId):
848 
    """
849 
    Mark order as cancellation request received. If customer sends request of cancellation of
850 
    a particular order, this method will be called. It will just change status of the order
851 
    depending on its current status. It also records the previous status, so that we can move
852 
    back to that status if cancellation request is denied.
4018 chandransh 853 
 
4247 rajveer 854 
    Parameters:
855 
     - orderId
856 
    """
857 
    pass
858 
 
859 
  def markOrderCancellationRequestConfirmed(self, orderId):
860 
    """
861 
    If we decide to to cancel order, CRM will call this method to move the status of order to
862 
    cancellation request confirmed. After this OM will be able to cancel the order.
863 
 
864 
    Parameters:
865 
     - orderId
866 
    """
867 
    pass
868 
 
869 
  def markOrderCancellationRequestDenied(self, orderId):
870 
    """
871 
    If we decide to not to cancel order, we will move the order ro previous status.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
4258 rajveer 878 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 879 
    """
4258 rajveer 880 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
881 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 882 
 
883 
    Parameters:
4258 rajveer 884 
     - transactionId
4247 rajveer 885 
    """
886 
    pass
887 
 
4259 anupam.sin 888 
  def refundTransaction(self, transactionId, refundedBy, reason):
889 
    """
890 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
891 
    need to be cancelled
4247 rajveer 892 
 
4259 anupam.sin 893 
    Parameters:
894 
     - transactionId
895 
     - refundedBy
896 
     - reason
897 
    """
898 
    pass
899 
 
4324 mandeep.dh 900 
  def updateShipmentAddress(self, orderId, addressId):
901 
    """
902 
    Updates shipment address of an order. Delivery and shipping date estimates
903 
    etc. are also updated here.
904 
 
905 
    Throws TransactionServiceException in case address change is not
906 
    possible due to certain reasons such as new pincode in address is
907 
    not serviceable etc.
908 
 
909 
    Parameters:
910 
     - orderId
911 
     - addressId
912 
    """
913 
    pass
914 
 
4285 rajveer 915 
  def acceptOrdersForItemId(self, itemId, inventory):
916 
    """
917 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
918 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 919 
 
4285 rajveer 920 
    Parameters:
921 
     - itemId
922 
     - inventory
923 
    """
924 
    pass
925 
 
4369 rajveer 926 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 927 
    """
928 
    Parameters:
929 
     - vendorId
930 
     - itemId
931 
     - quantity
932 
     - estimate
4369 rajveer 933 
     - isReminder
4303 rajveer 934 
    """
935 
    pass
4285 rajveer 936 
 
4369 rajveer 937 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 938 
    """
939 
    Parameters:
940 
     - vendorId
941 
     - itemId
942 
     - quantity
943 
     - estimate
4369 rajveer 944 
     - isReminder
4303 rajveer 945 
    """
946 
    pass
947 
 
4369 rajveer 948 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 949 
    """
950 
    Parameters:
951 
     - vendorId
952 
     - itemId
953 
     - quantity
954 
     - estimate
4369 rajveer 955 
     - isReminder
4303 rajveer 956 
    """
957 
    pass
958 
 
4369 rajveer 959 
  def markOrdersAsTimeout(self, vendorId):
960 
    """
961 
    Parameters:
962 
     - vendorId
963 
    """
964 
    pass
4303 rajveer 965 
 
4662 rajveer 966 
  def markOrderAsLostInTransit(self, orderId):
967 
    """
968 
    Mark order as LOST_IN_TRANSIT
969 
 
970 
    Parameters:
971 
     - orderId
972 
    """
973 
    pass
974 
 
4386 anupam.sin 975 
  def getOrderForAwb(self, awb):
976 
    """
977 
    Returns the order corresponding to an AWB number
4369 rajveer 978 
 
4386 anupam.sin 979 
    Parameters:
980 
     - awb
981 
    """
982 
    pass
983 
 
4910 phani.kuma 984 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 985 
    """
4910 phani.kuma 986 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 987 
 
4506 phani.kuma 988 
    Parameters:
989 
     - logistics_provider_id
4910 phani.kuma 990 
     - order_status_list
4506 phani.kuma 991 
    """
992 
    pass
993 
 
4600 varun.gupt 994 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
995 
    """
996 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 997 
 
4600 varun.gupt 998 
    Parameters:
999 
     - vendorId
1000 
     - billingDateFrom
1001 
     - billingDateTo
1002 
    """
1003 
    pass
1004 
 
4607 rajveer 1005 
  def getSlippedSippingDateOrders(self, ):
1006 
    pass
1007 
 
4709 rajveer 1008 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1009 
    """
1010 
    Parameters:
1011 
     - cancelDateFrom
1012 
     - cancelDateTo
1013 
    """
1014 
    pass
1015 
 
4600 varun.gupt 1016 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1017 
    """
1018 
    Parameters:
1019 
     - mapAWBAndAmount
1020 
    """
1021 
    pass
1022 
 
4905 varun.gupt 1023 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1024 
    """
1025 
    Parameters:
1026 
     - settlementDate
1027 
     - paymentGatewayId
4905 varun.gupt 1028 
     - referenceId
4600 varun.gupt 1029 
     - serviceTax
1030 
     - otherCharges
1031 
     - netCollection
1032 
    """
1033 
    pass
1034 
 
1035 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1036 
    """
1037 
    Parameters:
1038 
     - settlementId
1039 
     - settlementDate
1040 
     - transactionDateFrom
1041 
     - transactionDateTo
1042 
     - amount
1043 
    """
1044 
    pass
1045 
 
1046 
  def getSettlementForPaymentId(self, paymentId):
1047 
    """
1048 
    Parameters:
1049 
     - paymentId
1050 
    """
1051 
    pass
1052 
 
1053 
  def getEBSSettlementSummaries(self, ):
1054 
    pass
1055 
 
1056 
  def markEBSSettlementUploaded(self, settlementId):
1057 
    """
1058 
    Parameters:
1059 
     - settlementId
1060 
    """
1061 
    pass
1062 
 
1063 
  def getEBSSettlementDate(self, settlementId):
1064 
    """
1065 
    Parameters:
1066 
     - settlementId
1067 
    """
1068 
    pass
1069 
 
4715 varun.gupt 1070 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1071 
    """
1072 
    Parameters:
1073 
     - settlementDateFrom
1074 
     - settlementDateTo
1075 
     - isRefund
1076 
    """
1077 
    pass
4600 varun.gupt 1078 
 
4715 varun.gupt 1079 
  def getReshippedOrderIds(self, orderIds):
1080 
    """
1081 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1082 
 
1083 
    Parameters:
1084 
     - orderIds
1085 
    """
1086 
    pass
1087 
 
4757 mandeep.dh 1088 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1089 
    """
1090 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1091 
    the quantities for which the PO is raised.
4715 varun.gupt 1092 
 
4757 mandeep.dh 1093 
    Parameters:
1094 
     - itemIdQuantityMap
1095 
     - purchaseOrderId
1096 
     - warehouseId
1097 
    """
1098 
    pass
1099 
 
4875 varun.gupt 1100 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1101 
    """
1102 
    Parameters:
1103 
     - vendorId
1104 
    """
1105 
    pass
4757 mandeep.dh 1106 
 
4875 varun.gupt 1107 
 
3376 rajveer 1108 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1109 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1110 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1111 
 
1112 
  def createTransaction(self, transaction):
1113 
    """
1114 
    Parameters:
1115 
     - transaction
1116 
    """
1117 
    self.send_createTransaction(transaction)
132 ashish 1118 
    return self.recv_createTransaction()
94 ashish 1119 
 
1120 
  def send_createTransaction(self, transaction):
1121 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1122 
    args = createTransaction_args()
1123 
    args.transaction = transaction
1124 
    args.write(self._oprot)
1125 
    self._oprot.writeMessageEnd()
1126 
    self._oprot.trans.flush()
1127 
 
1128 
  def recv_createTransaction(self, ):
1129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1130 
    if mtype == TMessageType.EXCEPTION:
1131 
      x = TApplicationException()
1132 
      x.read(self._iprot)
1133 
      self._iprot.readMessageEnd()
1134 
      raise x
1135 
    result = createTransaction_result()
1136 
    result.read(self._iprot)
1137 
    self._iprot.readMessageEnd()
3431 rajveer 1138 
    if result.success is not None:
132 ashish 1139 
      return result.success
3431 rajveer 1140 
    if result.ex is not None:
94 ashish 1141 
      raise result.ex
132 ashish 1142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1143 
 
1144 
  def getTransaction(self, id):
1145 
    """
1146 
    Parameters:
1147 
     - id
1148 
    """
1149 
    self.send_getTransaction(id)
1150 
    return self.recv_getTransaction()
1151 
 
1152 
  def send_getTransaction(self, id):
1153 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1154 
    args = getTransaction_args()
1155 
    args.id = id
1156 
    args.write(self._oprot)
1157 
    self._oprot.writeMessageEnd()
1158 
    self._oprot.trans.flush()
1159 
 
1160 
  def recv_getTransaction(self, ):
1161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1162 
    if mtype == TMessageType.EXCEPTION:
1163 
      x = TApplicationException()
1164 
      x.read(self._iprot)
1165 
      self._iprot.readMessageEnd()
1166 
      raise x
1167 
    result = getTransaction_result()
1168 
    result.read(self._iprot)
1169 
    self._iprot.readMessageEnd()
3431 rajveer 1170 
    if result.success is not None:
94 ashish 1171 
      return result.success
3431 rajveer 1172 
    if result.ex is not None:
94 ashish 1173 
      raise result.ex
1174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1175 
 
1176 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1177 
    """
1178 
    Parameters:
1179 
     - customerId
1180 
     - from_date
1181 
     - to_date
1182 
     - status
1183 
    """
1184 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1185 
    return self.recv_getTransactionsForCustomer()
1186 
 
1187 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1188 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1189 
    args = getTransactionsForCustomer_args()
1190 
    args.customerId = customerId
1191 
    args.from_date = from_date
1192 
    args.to_date = to_date
1193 
    args.status = status
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getTransactionsForCustomer(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getTransactionsForCustomer_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
3431 rajveer 1208 
    if result.success is not None:
94 ashish 1209 
      return result.success
3431 rajveer 1210 
    if result.ex is not None:
94 ashish 1211 
      raise result.ex
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1213 
 
132 ashish 1214 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1215 
    """
1216 
    Parameters:
1217 
     - shoppingCartId
1218 
    """
1219 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1220 
    return self.recv_getTransactionsForShoppingCartId()
1221 
 
1222 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1223 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1224 
    args = getTransactionsForShoppingCartId_args()
1225 
    args.shoppingCartId = shoppingCartId
1226 
    args.write(self._oprot)
1227 
    self._oprot.writeMessageEnd()
1228 
    self._oprot.trans.flush()
1229 
 
1230 
  def recv_getTransactionsForShoppingCartId(self, ):
1231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1232 
    if mtype == TMessageType.EXCEPTION:
1233 
      x = TApplicationException()
1234 
      x.read(self._iprot)
1235 
      self._iprot.readMessageEnd()
1236 
      raise x
1237 
    result = getTransactionsForShoppingCartId_result()
1238 
    result.read(self._iprot)
1239 
    self._iprot.readMessageEnd()
3431 rajveer 1240 
    if result.success is not None:
132 ashish 1241 
      return result.success
3431 rajveer 1242 
    if result.ex is not None:
132 ashish 1243 
      raise result.ex
1244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1245 
 
94 ashish 1246 
  def getTransactionStatus(self, transactionId):
1247 
    """
1248 
    Parameters:
1249 
     - transactionId
1250 
    """
1251 
    self.send_getTransactionStatus(transactionId)
1252 
    return self.recv_getTransactionStatus()
1253 
 
1254 
  def send_getTransactionStatus(self, transactionId):
1255 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1256 
    args = getTransactionStatus_args()
1257 
    args.transactionId = transactionId
1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
1262 
  def recv_getTransactionStatus(self, ):
1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
1269 
    result = getTransactionStatus_result()
1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
3431 rajveer 1272 
    if result.success is not None:
94 ashish 1273 
      return result.success
3431 rajveer 1274 
    if result.ex is not None:
94 ashish 1275 
      raise result.ex
1276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1277 
 
1278 
  def changeTransactionStatus(self, transactionId, status, description):
1279 
    """
1280 
    Parameters:
1281 
     - transactionId
1282 
     - status
1283 
     - description
1284 
    """
1285 
    self.send_changeTransactionStatus(transactionId, status, description)
1286 
    return self.recv_changeTransactionStatus()
1287 
 
1288 
  def send_changeTransactionStatus(self, transactionId, status, description):
1289 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1290 
    args = changeTransactionStatus_args()
1291 
    args.transactionId = transactionId
1292 
    args.status = status
1293 
    args.description = description
1294 
    args.write(self._oprot)
1295 
    self._oprot.writeMessageEnd()
1296 
    self._oprot.trans.flush()
1297 
 
1298 
  def recv_changeTransactionStatus(self, ):
1299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1300 
    if mtype == TMessageType.EXCEPTION:
1301 
      x = TApplicationException()
1302 
      x.read(self._iprot)
1303 
      self._iprot.readMessageEnd()
1304 
      raise x
1305 
    result = changeTransactionStatus_result()
1306 
    result.read(self._iprot)
1307 
    self._iprot.readMessageEnd()
3431 rajveer 1308 
    if result.success is not None:
94 ashish 1309 
      return result.success
3431 rajveer 1310 
    if result.ex is not None:
94 ashish 1311 
      raise result.ex
1312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1313 
 
1398 varun.gupt 1314 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1315 
    """
1316 
    Parameters:
1317 
     - transactionId
1318 
    """
1398 varun.gupt 1319 
    self.send_enqueueTransactionInfoEmail(transactionId)
1320 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1321 
 
1398 varun.gupt 1322 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1323 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1324 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1325 
    args.transactionId = transactionId
1326 
    args.write(self._oprot)
1327 
    self._oprot.writeMessageEnd()
1328 
    self._oprot.trans.flush()
1329 
 
1398 varun.gupt 1330 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1332 
    if mtype == TMessageType.EXCEPTION:
1333 
      x = TApplicationException()
1334 
      x.read(self._iprot)
1335 
      self._iprot.readMessageEnd()
1336 
      raise x
1398 varun.gupt 1337 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1338 
    result.read(self._iprot)
1339 
    self._iprot.readMessageEnd()
3431 rajveer 1340 
    if result.success is not None:
1382 varun.gupt 1341 
      return result.success
3431 rajveer 1342 
    if result.ex is not None:
1382 varun.gupt 1343 
      raise result.ex
1398 varun.gupt 1344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1345 
 
4801 anupam.sin 1346 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1347 
    """
1348 
    Parameters:
4801 anupam.sin 1349 
     - statuses
483 rajveer 1350 
     - from_date
1351 
     - to_date
1352 
     - warehouse_id
94 ashish 1353 
    """
4801 anupam.sin 1354 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1355 
    return self.recv_getAllOrders()
94 ashish 1356 
 
4801 anupam.sin 1357 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1358 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1359 
    args = getAllOrders_args()
4801 anupam.sin 1360 
    args.statuses = statuses
483 rajveer 1361 
    args.from_date = from_date
1362 
    args.to_date = to_date
1363 
    args.warehouse_id = warehouse_id
94 ashish 1364 
    args.write(self._oprot)
1365 
    self._oprot.writeMessageEnd()
1366 
    self._oprot.trans.flush()
1367 
 
483 rajveer 1368 
  def recv_getAllOrders(self, ):
94 ashish 1369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1370 
    if mtype == TMessageType.EXCEPTION:
1371 
      x = TApplicationException()
1372 
      x.read(self._iprot)
1373 
      self._iprot.readMessageEnd()
1374 
      raise x
483 rajveer 1375 
    result = getAllOrders_result()
94 ashish 1376 
    result.read(self._iprot)
1377 
    self._iprot.readMessageEnd()
3431 rajveer 1378 
    if result.success is not None:
94 ashish 1379 
      return result.success
3431 rajveer 1380 
    if result.ex is not None:
94 ashish 1381 
      raise result.ex
483 rajveer 1382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1383 
 
4133 chandransh 1384 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1385 
    """
1386 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1387 
    Pass the status as null and the limit as 0 to ignore them.
1388 
 
1389 
    Parameters:
1390 
     - statuses
1391 
     - offset
1392 
     - limit
1393 
     - warehouse_id
1394 
    """
1395 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1396 
    return self.recv_getOrdersInBatch()
1397 
 
1398 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1399 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1400 
    args = getOrdersInBatch_args()
1401 
    args.statuses = statuses
1402 
    args.offset = offset
1403 
    args.limit = limit
1404 
    args.warehouse_id = warehouse_id
1405 
    args.write(self._oprot)
1406 
    self._oprot.writeMessageEnd()
1407 
    self._oprot.trans.flush()
1408 
 
1409 
  def recv_getOrdersInBatch(self, ):
1410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1411 
    if mtype == TMessageType.EXCEPTION:
1412 
      x = TApplicationException()
1413 
      x.read(self._iprot)
1414 
      self._iprot.readMessageEnd()
1415 
      raise x
1416 
    result = getOrdersInBatch_result()
1417 
    result.read(self._iprot)
1418 
    self._iprot.readMessageEnd()
1419 
    if result.success is not None:
1420 
      return result.success
1421 
    if result.ex is not None:
1422 
      raise result.ex
1423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1424 
 
1425 
  def getOrderCount(self, statuses, warehouseId):
1426 
    """
1427 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1428 
 
1429 
    Parameters:
1430 
     - statuses
1431 
     - warehouseId
1432 
    """
1433 
    self.send_getOrderCount(statuses, warehouseId)
1434 
    return self.recv_getOrderCount()
1435 
 
1436 
  def send_getOrderCount(self, statuses, warehouseId):
1437 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1438 
    args = getOrderCount_args()
1439 
    args.statuses = statuses
1440 
    args.warehouseId = warehouseId
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getOrderCount(self, ):
1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
1452 
    result = getOrderCount_result()
1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
1455 
    if result.success is not None:
1456 
      return result.success
1457 
    if result.ex is not None:
1458 
      raise result.ex
1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1460 
 
999 varun.gupt 1461 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1462 
    """
1132 chandransh 1463 
    Returns orders within a range of their billing dates
3431 rajveer 1464 
 
999 varun.gupt 1465 
    Parameters:
1466 
     - status
1467 
     - start_billing_date
1468 
     - end_billing_date
1469 
     - warehouse_id
1470 
    """
1471 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1472 
    return self.recv_getOrdersByBillingDate()
1473 
 
1474 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1475 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1476 
    args = getOrdersByBillingDate_args()
1477 
    args.status = status
1478 
    args.start_billing_date = start_billing_date
1479 
    args.end_billing_date = end_billing_date
1480 
    args.warehouse_id = warehouse_id
1481 
    args.write(self._oprot)
1482 
    self._oprot.writeMessageEnd()
1483 
    self._oprot.trans.flush()
1484 
 
1485 
  def recv_getOrdersByBillingDate(self, ):
1486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1487 
    if mtype == TMessageType.EXCEPTION:
1488 
      x = TApplicationException()
1489 
      x.read(self._iprot)
1490 
      self._iprot.readMessageEnd()
1491 
      raise x
1492 
    result = getOrdersByBillingDate_result()
1493 
    result.read(self._iprot)
1494 
    self._iprot.readMessageEnd()
3431 rajveer 1495 
    if result.success is not None:
999 varun.gupt 1496 
      return result.success
3431 rajveer 1497 
    if result.ex is not None:
999 varun.gupt 1498 
      raise result.ex
1499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1500 
 
3451 chandransh 1501 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1502 
    """
1503 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1504 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1505 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1506 
 
3427 chandransh 1507 
    Parameters:
1508 
     - fromShippingDate
1509 
     - toShippingDate
1510 
     - providerId
1511 
     - warehouseId
3451 chandransh 1512 
     - cod
3427 chandransh 1513 
    """
3451 chandransh 1514 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1515 
    return self.recv_getOrdersByShippingDate()
1516 
 
3451 chandransh 1517 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1518 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1519 
    args = getOrdersByShippingDate_args()
1520 
    args.fromShippingDate = fromShippingDate
1521 
    args.toShippingDate = toShippingDate
1522 
    args.providerId = providerId
1523 
    args.warehouseId = warehouseId
3451 chandransh 1524 
    args.cod = cod
3427 chandransh 1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getOrdersByShippingDate(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getOrdersByShippingDate_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
3431 rajveer 1539 
    if result.success is not None:
3427 chandransh 1540 
      return result.success
3431 rajveer 1541 
    if result.ex is not None:
3427 chandransh 1542 
      raise result.ex
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1544 
 
1382 varun.gupt 1545 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1546 
    """
1547 
    Returns order ids for orders which can be returned
3431 rajveer 1548 
 
1382 varun.gupt 1549 
    Parameters:
1550 
     - customer_id
1551 
     - limit
1552 
    """
1553 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1554 
    return self.recv_getReturnableOrdersForCustomer()
1555 
 
1556 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1557 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1558 
    args = getReturnableOrdersForCustomer_args()
1559 
    args.customer_id = customer_id
1560 
    args.limit = limit
1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
1565 
  def recv_getReturnableOrdersForCustomer(self, ):
1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
1572 
    result = getReturnableOrdersForCustomer_result()
1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
3431 rajveer 1575 
    if result.success is not None:
1382 varun.gupt 1576 
      return result.success
3431 rajveer 1577 
    if result.ex is not None:
1382 varun.gupt 1578 
      raise result.ex
1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1580 
 
1581 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1582 
    """
1583 
    Returns order ids for orders which can be cancelled
3431 rajveer 1584 
 
1382 varun.gupt 1585 
    Parameters:
1586 
     - customer_id
1587 
     - limit
1588 
    """
1589 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1590 
    return self.recv_getCancellableOrdersForCustomer()
1591 
 
1592 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1593 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1594 
    args = getCancellableOrdersForCustomer_args()
1595 
    args.customer_id = customer_id
1596 
    args.limit = limit
1597 
    args.write(self._oprot)
1598 
    self._oprot.writeMessageEnd()
1599 
    self._oprot.trans.flush()
1600 
 
1601 
  def recv_getCancellableOrdersForCustomer(self, ):
1602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1603 
    if mtype == TMessageType.EXCEPTION:
1604 
      x = TApplicationException()
1605 
      x.read(self._iprot)
1606 
      self._iprot.readMessageEnd()
1607 
      raise x
1608 
    result = getCancellableOrdersForCustomer_result()
1609 
    result.read(self._iprot)
1610 
    self._iprot.readMessageEnd()
3431 rajveer 1611 
    if result.success is not None:
1382 varun.gupt 1612 
      return result.success
3431 rajveer 1613 
    if result.ex is not None:
1382 varun.gupt 1614 
      raise result.ex
1615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1616 
 
483 rajveer 1617 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1618 
    """
1619 
    Parameters:
483 rajveer 1620 
     - orderId
1621 
     - status
1622 
     - description
94 ashish 1623 
    """
483 rajveer 1624 
    self.send_changeOrderStatus(orderId, status, description)
1625 
    return self.recv_changeOrderStatus()
94 ashish 1626 
 
483 rajveer 1627 
  def send_changeOrderStatus(self, orderId, status, description):
1628 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1629 
    args = changeOrderStatus_args()
1630 
    args.orderId = orderId
1631 
    args.status = status
1632 
    args.description = description
94 ashish 1633 
    args.write(self._oprot)
1634 
    self._oprot.writeMessageEnd()
1635 
    self._oprot.trans.flush()
1636 
 
483 rajveer 1637 
  def recv_changeOrderStatus(self, ):
94 ashish 1638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1639 
    if mtype == TMessageType.EXCEPTION:
1640 
      x = TApplicationException()
1641 
      x.read(self._iprot)
1642 
      self._iprot.readMessageEnd()
1643 
      raise x
483 rajveer 1644 
    result = changeOrderStatus_result()
94 ashish 1645 
    result.read(self._iprot)
1646 
    self._iprot.readMessageEnd()
3431 rajveer 1647 
    if result.success is not None:
94 ashish 1648 
      return result.success
3431 rajveer 1649 
    if result.ex is not None:
94 ashish 1650 
      raise result.ex
483 rajveer 1651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1652 
 
1528 ankur.sing 1653 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1654 
    """
1528 ankur.sing 1655 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1656 
    only user who owns the transaction can view its order details.
3431 rajveer 1657 
 
94 ashish 1658 
    Parameters:
1659 
     - transactionId
1528 ankur.sing 1660 
     - customerId
94 ashish 1661 
    """
1528 ankur.sing 1662 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1663 
    return self.recv_getOrdersForTransaction()
94 ashish 1664 
 
1528 ankur.sing 1665 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1666 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1667 
    args = getOrdersForTransaction_args()
94 ashish 1668 
    args.transactionId = transactionId
1528 ankur.sing 1669 
    args.customerId = customerId
94 ashish 1670 
    args.write(self._oprot)
1671 
    self._oprot.writeMessageEnd()
1672 
    self._oprot.trans.flush()
1673 
 
483 rajveer 1674 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1676 
    if mtype == TMessageType.EXCEPTION:
1677 
      x = TApplicationException()
1678 
      x.read(self._iprot)
1679 
      self._iprot.readMessageEnd()
1680 
      raise x
483 rajveer 1681 
    result = getOrdersForTransaction_result()
94 ashish 1682 
    result.read(self._iprot)
1683 
    self._iprot.readMessageEnd()
3431 rajveer 1684 
    if result.success is not None:
94 ashish 1685 
      return result.success
3431 rajveer 1686 
    if result.ex is not None:
94 ashish 1687 
      raise result.ex
483 rajveer 1688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1689 
 
3014 chandransh 1690 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1691 
    """
3014 chandransh 1692 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1693 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1694 
 
94 ashish 1695 
    Parameters:
483 rajveer 1696 
     - customerId
1697 
     - from_date
1698 
     - to_date
3014 chandransh 1699 
     - statuses
94 ashish 1700 
    """
3014 chandransh 1701 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1702 
    return self.recv_getOrdersForCustomer()
94 ashish 1703 
 
3014 chandransh 1704 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1705 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1706 
    args = getOrdersForCustomer_args()
1707 
    args.customerId = customerId
1708 
    args.from_date = from_date
1709 
    args.to_date = to_date
3014 chandransh 1710 
    args.statuses = statuses
94 ashish 1711 
    args.write(self._oprot)
1712 
    self._oprot.writeMessageEnd()
1713 
    self._oprot.trans.flush()
1714 
 
483 rajveer 1715 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1717 
    if mtype == TMessageType.EXCEPTION:
1718 
      x = TApplicationException()
1719 
      x.read(self._iprot)
1720 
      self._iprot.readMessageEnd()
1721 
      raise x
483 rajveer 1722 
    result = getOrdersForCustomer_result()
94 ashish 1723 
    result.read(self._iprot)
1724 
    self._iprot.readMessageEnd()
3431 rajveer 1725 
    if result.success is not None:
94 ashish 1726 
      return result.success
3431 rajveer 1727 
    if result.ex is not None:
94 ashish 1728 
      raise result.ex
483 rajveer 1729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1730 
 
483 rajveer 1731 
  def createOrder(self, order):
94 ashish 1732 
    """
1733 
    Parameters:
483 rajveer 1734 
     - order
94 ashish 1735 
    """
483 rajveer 1736 
    self.send_createOrder(order)
1737 
    return self.recv_createOrder()
94 ashish 1738 
 
483 rajveer 1739 
  def send_createOrder(self, order):
1740 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1741 
    args = createOrder_args()
1742 
    args.order = order
94 ashish 1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
483 rajveer 1747 
  def recv_createOrder(self, ):
94 ashish 1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
483 rajveer 1754 
    result = createOrder_result()
94 ashish 1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
3431 rajveer 1757 
    if result.success is not None:
94 ashish 1758 
      return result.success
3431 rajveer 1759 
    if result.ex is not None:
94 ashish 1760 
      raise result.ex
483 rajveer 1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1762 
 
483 rajveer 1763 
  def getOrder(self, id):
94 ashish 1764 
    """
1765 
    Parameters:
483 rajveer 1766 
     - id
94 ashish 1767 
    """
483 rajveer 1768 
    self.send_getOrder(id)
1769 
    return self.recv_getOrder()
94 ashish 1770 
 
483 rajveer 1771 
  def send_getOrder(self, id):
1772 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1773 
    args = getOrder_args()
1774 
    args.id = id
94 ashish 1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
483 rajveer 1779 
  def recv_getOrder(self, ):
94 ashish 1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
483 rajveer 1786 
    result = getOrder_result()
94 ashish 1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
3431 rajveer 1789 
    if result.success is not None:
94 ashish 1790 
      return result.success
3431 rajveer 1791 
    if result.ex is not None:
94 ashish 1792 
      raise result.ex
483 rajveer 1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1794 
 
483 rajveer 1795 
  def getLineItemsForOrder(self, orderId):
94 ashish 1796 
    """
1797 
    Parameters:
483 rajveer 1798 
     - orderId
94 ashish 1799 
    """
483 rajveer 1800 
    self.send_getLineItemsForOrder(orderId)
1801 
    return self.recv_getLineItemsForOrder()
94 ashish 1802 
 
483 rajveer 1803 
  def send_getLineItemsForOrder(self, orderId):
1804 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1805 
    args = getLineItemsForOrder_args()
1806 
    args.orderId = orderId
94 ashish 1807 
    args.write(self._oprot)
1808 
    self._oprot.writeMessageEnd()
1809 
    self._oprot.trans.flush()
1810 
 
483 rajveer 1811 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1813 
    if mtype == TMessageType.EXCEPTION:
1814 
      x = TApplicationException()
1815 
      x.read(self._iprot)
1816 
      self._iprot.readMessageEnd()
1817 
      raise x
483 rajveer 1818 
    result = getLineItemsForOrder_result()
94 ashish 1819 
    result.read(self._iprot)
1820 
    self._iprot.readMessageEnd()
3431 rajveer 1821 
    if result.success is not None:
94 ashish 1822 
      return result.success
3431 rajveer 1823 
    if result.ex is not None:
94 ashish 1824 
      raise result.ex
483 rajveer 1825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1826 
 
4999 phani.kuma 1827 
  def getOrderList(self, order_ids):
1828 
    """
1829 
    Parameters:
1830 
     - order_ids
1831 
    """
1832 
    self.send_getOrderList(order_ids)
1833 
    return self.recv_getOrderList()
1834 
 
1835 
  def send_getOrderList(self, order_ids):
1836 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1837 
    args = getOrderList_args()
1838 
    args.order_ids = order_ids
1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_getOrderList(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = getOrderList_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
1853 
    if result.success is not None:
1854 
      return result.success
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1856 
 
1528 ankur.sing 1857 
  def getOrderForCustomer(self, orderId, customerId):
1858 
    """
1859 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1860 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1861 
 
1528 ankur.sing 1862 
    Parameters:
1863 
     - orderId
1864 
     - customerId
1865 
    """
1866 
    self.send_getOrderForCustomer(orderId, customerId)
1867 
    return self.recv_getOrderForCustomer()
1868 
 
1869 
  def send_getOrderForCustomer(self, orderId, customerId):
1870 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1871 
    args = getOrderForCustomer_args()
1872 
    args.orderId = orderId
1873 
    args.customerId = customerId
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getOrderForCustomer(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getOrderForCustomer_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
1528 ankur.sing 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
1528 ankur.sing 1891 
      raise result.ex
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1893 
 
4444 rajveer 1894 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1895 
    """
1896 
    Parameters:
4394 rajveer 1897 
     - type
4444 rajveer 1898 
     - warehouseId
4394 rajveer 1899 
     - status
1900 
     - timestamp
3064 chandransh 1901 
    """
4444 rajveer 1902 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1903 
    return self.recv_getAlerts()
1904 
 
4444 rajveer 1905 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1906 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1907 
    args = getAlerts_args()
4394 rajveer 1908 
    args.type = type
4444 rajveer 1909 
    args.warehouseId = warehouseId
4394 rajveer 1910 
    args.status = status
1911 
    args.timestamp = timestamp
3064 chandransh 1912 
    args.write(self._oprot)
1913 
    self._oprot.writeMessageEnd()
1914 
    self._oprot.trans.flush()
1915 
 
1916 
  def recv_getAlerts(self, ):
1917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1918 
    if mtype == TMessageType.EXCEPTION:
1919 
      x = TApplicationException()
1920 
      x.read(self._iprot)
1921 
      self._iprot.readMessageEnd()
1922 
      raise x
1923 
    result = getAlerts_result()
1924 
    result.read(self._iprot)
1925 
    self._iprot.readMessageEnd()
3431 rajveer 1926 
    if result.success is not None:
3064 chandransh 1927 
      return result.success
1928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1929 
 
4444 rajveer 1930 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1931 
    """
1932 
    Parameters:
1933 
     - type
4444 rajveer 1934 
     - warehouseId
4394 rajveer 1935 
     - description
3064 chandransh 1936 
    """
4444 rajveer 1937 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1938 
    self.recv_addAlert()
3064 chandransh 1939 
 
4444 rajveer 1940 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1941 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1942 
    args = addAlert_args()
3064 chandransh 1943 
    args.type = type
4444 rajveer 1944 
    args.warehouseId = warehouseId
4394 rajveer 1945 
    args.description = description
3064 chandransh 1946 
    args.write(self._oprot)
1947 
    self._oprot.writeMessageEnd()
1948 
    self._oprot.trans.flush()
1949 
 
4394 rajveer 1950 
  def recv_addAlert(self, ):
3064 chandransh 1951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1952 
    if mtype == TMessageType.EXCEPTION:
1953 
      x = TApplicationException()
1954 
      x.read(self._iprot)
1955 
      self._iprot.readMessageEnd()
1956 
      raise x
4394 rajveer 1957 
    result = addAlert_result()
3064 chandransh 1958 
    result.read(self._iprot)
1959 
    self._iprot.readMessageEnd()
1960 
    return
1961 
 
4444 rajveer 1962 
  def markAlertsAsSeen(self, warehouseId):
1963 
    """
1964 
    Parameters:
1965 
     - warehouseId
1966 
    """
1967 
    self.send_markAlertsAsSeen(warehouseId)
1968 
    self.recv_markAlertsAsSeen()
1969 
 
1970 
  def send_markAlertsAsSeen(self, warehouseId):
1971 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1972 
    args = markAlertsAsSeen_args()
1973 
    args.warehouseId = warehouseId
1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
1978 
  def recv_markAlertsAsSeen(self, ):
1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
1985 
    result = markAlertsAsSeen_result()
1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
1988 
    return
1989 
 
3064 chandransh 1990 
  def getValidOrderCount(self, ):
1991 
    """
1992 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1993 
    """
1994 
    self.send_getValidOrderCount()
1995 
    return self.recv_getValidOrderCount()
1996 
 
1997 
  def send_getValidOrderCount(self, ):
1998 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1999 
    args = getValidOrderCount_args()
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getValidOrderCount(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getValidOrderCount_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
3431 rajveer 2014 
    if result.success is not None:
3064 chandransh 2015 
      return result.success
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2017 
 
2018 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2019 
    """
2020 
    Returns the number of distinct customers who have done successful transactions
2021 
    """
2022 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2023 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2024 
 
2025 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2026 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2027 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2028 
    args.write(self._oprot)
2029 
    self._oprot.writeMessageEnd()
2030 
    self._oprot.trans.flush()
2031 
 
2032 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2034 
    if mtype == TMessageType.EXCEPTION:
2035 
      x = TApplicationException()
2036 
      x.read(self._iprot)
2037 
      self._iprot.readMessageEnd()
2038 
      raise x
2039 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2040 
    result.read(self._iprot)
2041 
    self._iprot.readMessageEnd()
3431 rajveer 2042 
    if result.success is not None:
3064 chandransh 2043 
      return result.success
2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2045 
 
2046 
  def getValidOrdersAmountRange(self, ):
2047 
    """
2048 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2049 
    List contains two values, first minimum amount and second maximum amount.
2050 
    """
2051 
    self.send_getValidOrdersAmountRange()
2052 
    return self.recv_getValidOrdersAmountRange()
2053 
 
2054 
  def send_getValidOrdersAmountRange(self, ):
2055 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2056 
    args = getValidOrdersAmountRange_args()
2057 
    args.write(self._oprot)
2058 
    self._oprot.writeMessageEnd()
2059 
    self._oprot.trans.flush()
2060 
 
2061 
  def recv_getValidOrdersAmountRange(self, ):
2062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2063 
    if mtype == TMessageType.EXCEPTION:
2064 
      x = TApplicationException()
2065 
      x.read(self._iprot)
2066 
      self._iprot.readMessageEnd()
2067 
      raise x
2068 
    result = getValidOrdersAmountRange_result()
2069 
    result.read(self._iprot)
2070 
    self._iprot.readMessageEnd()
3431 rajveer 2071 
    if result.success is not None:
3064 chandransh 2072 
      return result.success
2073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2074 
 
2075 
  def getValidOrders(self, limit):
2076 
    """
2077 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2078 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2079 
 
3064 chandransh 2080 
    Parameters:
2081 
     - limit
2082 
    """
2083 
    self.send_getValidOrders(limit)
2084 
    return self.recv_getValidOrders()
2085 
 
2086 
  def send_getValidOrders(self, limit):
2087 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2088 
    args = getValidOrders_args()
2089 
    args.limit = limit
2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
2094 
  def recv_getValidOrders(self, ):
2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
2101 
    result = getValidOrders_result()
2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.success is not None:
3064 chandransh 2105 
      return result.success
2106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2107 
 
1220 chandransh 2108 
  def batchOrders(self, warehouseId):
2109 
    """
2110 
    Create a batch of all the pending orders for the given warehouse.
2111 
    The returned list is orderd by created_timestamp.
2112 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2113 
 
1220 chandransh 2114 
    Parameters:
2115 
     - warehouseId
2116 
    """
2117 
    self.send_batchOrders(warehouseId)
2118 
    return self.recv_batchOrders()
2119 
 
2120 
  def send_batchOrders(self, warehouseId):
2121 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2122 
    args = batchOrders_args()
2123 
    args.warehouseId = warehouseId
2124 
    args.write(self._oprot)
2125 
    self._oprot.writeMessageEnd()
2126 
    self._oprot.trans.flush()
2127 
 
2128 
  def recv_batchOrders(self, ):
2129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2130 
    if mtype == TMessageType.EXCEPTION:
2131 
      x = TApplicationException()
2132 
      x.read(self._iprot)
2133 
      self._iprot.readMessageEnd()
2134 
      raise x
2135 
    result = batchOrders_result()
2136 
    result.read(self._iprot)
2137 
    self._iprot.readMessageEnd()
3431 rajveer 2138 
    if result.success is not None:
1220 chandransh 2139 
      return result.success
3431 rajveer 2140 
    if result.ex is not None:
1220 chandransh 2141 
      raise result.ex
2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2143 
 
1208 chandransh 2144 
  def markOrderAsOutOfStock(self, orderId):
2145 
    """
2146 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2147 
 
1208 chandransh 2148 
    Parameters:
2149 
     - orderId
2150 
    """
2151 
    self.send_markOrderAsOutOfStock(orderId)
2152 
    return self.recv_markOrderAsOutOfStock()
2153 
 
2154 
  def send_markOrderAsOutOfStock(self, orderId):
2155 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2156 
    args = markOrderAsOutOfStock_args()
2157 
    args.orderId = orderId
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_markOrderAsOutOfStock(self, ):
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
2169 
    result = markOrderAsOutOfStock_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
3431 rajveer 2172 
    if result.success is not None:
1208 chandransh 2173 
      return result.success
3431 rajveer 2174 
    if result.ex is not None:
1208 chandransh 2175 
      raise result.ex
2176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2177 
 
3064 chandransh 2178 
  def verifyOrder(self, orderId):
759 chandransh 2179 
    """
3064 chandransh 2180 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2181 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2182 
    used for all other orders as well.
2183 
    Throws an exception if no such order exists.
3431 rajveer 2184 
 
759 chandransh 2185 
    Parameters:
3064 chandransh 2186 
     - orderId
759 chandransh 2187 
    """
3064 chandransh 2188 
    self.send_verifyOrder(orderId)
2189 
    return self.recv_verifyOrder()
759 chandransh 2190 
 
3064 chandransh 2191 
  def send_verifyOrder(self, orderId):
2192 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2193 
    args = verifyOrder_args()
2194 
    args.orderId = orderId
759 chandransh 2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
3064 chandransh 2199 
  def recv_verifyOrder(self, ):
759 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 = verifyOrder_result()
759 chandransh 2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
3431 rajveer 2209 
    if result.success is not None:
759 chandransh 2210 
      return result.success
3431 rajveer 2211 
    if result.ex is not None:
759 chandransh 2212 
      raise result.ex
3064 chandransh 2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2214 
 
3064 chandransh 2215 
  def acceptOrder(self, orderId):
1113 chandransh 2216 
    """
3064 chandransh 2217 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2218 
    given order is not a COD order, it also captures the payment if the same has
2219 
    not been captured.
2220 
    Throws an exception if no such order exists.
3431 rajveer 2221 
 
1113 chandransh 2222 
    Parameters:
3064 chandransh 2223 
     - orderId
1113 chandransh 2224 
    """
3064 chandransh 2225 
    self.send_acceptOrder(orderId)
2226 
    return self.recv_acceptOrder()
1113 chandransh 2227 
 
3064 chandransh 2228 
  def send_acceptOrder(self, orderId):
2229 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2230 
    args = acceptOrder_args()
2231 
    args.orderId = orderId
1113 chandransh 2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
3064 chandransh 2236 
  def recv_acceptOrder(self, ):
1113 chandransh 2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
3064 chandransh 2243 
    result = acceptOrder_result()
1113 chandransh 2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
3431 rajveer 2246 
    if result.success is not None:
1113 chandransh 2247 
      return result.success
3431 rajveer 2248 
    if result.ex is not None:
1113 chandransh 2249 
      raise result.ex
3064 chandransh 2250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2251 
 
4763 rajveer 2252 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2253 
    """
3064 chandransh 2254 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2255 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2256 
    the IMEI no. if a -1 is supplied.
2257 
    Also, it generates an invoice number for the order, marks the order as
2258 
    BILLED and sets the billing timestamp.
2259 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2260 
 
1135 chandransh 2261 
    Parameters:
3064 chandransh 2262 
     - orderId
2263 
     - invoice_number
4658 mandeep.dh 2264 
     - serialNumber
4283 anupam.sin 2265 
     - itemNumber
3064 chandransh 2266 
     - billed_by
4264 rajveer 2267 
     - jacketNumber
4283 anupam.sin 2268 
     - billingType
2269 
     - vendorId
4763 rajveer 2270 
     - authorize
1135 chandransh 2271 
    """
4763 rajveer 2272 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2273 
    return self.recv_addBillingDetails()
1135 chandransh 2274 
 
4763 rajveer 2275 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2276 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2277 
    args = addBillingDetails_args()
2278 
    args.orderId = orderId
2279 
    args.invoice_number = invoice_number
4658 mandeep.dh 2280 
    args.serialNumber = serialNumber
4283 anupam.sin 2281 
    args.itemNumber = itemNumber
3064 chandransh 2282 
    args.billed_by = billed_by
4264 rajveer 2283 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2284 
    args.billingType = billingType
2285 
    args.vendorId = vendorId
4763 rajveer 2286 
    args.authorize = authorize
1135 chandransh 2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
3064 chandransh 2291 
  def recv_addBillingDetails(self, ):
1135 chandransh 2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
3064 chandransh 2298 
    result = addBillingDetails_result()
1135 chandransh 2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
3431 rajveer 2301 
    if result.success is not None:
3064 chandransh 2302 
      return result.success
3431 rajveer 2303 
    if result.ex is not None:
1135 chandransh 2304 
      raise result.ex
3064 chandransh 2305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2306 
 
4763 rajveer 2307 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2308 
    """
2309 
    Add the invoice number to the order.
2310 
 
2311 
    Parameters:
2312 
     - orderId
2313 
     - invoiceNumber
4763 rajveer 2314 
     - color
4579 rajveer 2315 
    """
4763 rajveer 2316 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2317 
    self.recv_addInvoiceNumber()
2318 
 
4763 rajveer 2319 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2320 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2321 
    args = addInvoiceNumber_args()
2322 
    args.orderId = orderId
2323 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2324 
    args.color = color
4579 rajveer 2325 
    args.write(self._oprot)
2326 
    self._oprot.writeMessageEnd()
2327 
    self._oprot.trans.flush()
2328 
 
2329 
  def recv_addInvoiceNumber(self, ):
2330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2331 
    if mtype == TMessageType.EXCEPTION:
2332 
      x = TApplicationException()
2333 
      x.read(self._iprot)
2334 
      self._iprot.readMessageEnd()
2335 
      raise x
2336 
    result = addInvoiceNumber_result()
2337 
    result.read(self._iprot)
2338 
    self._iprot.readMessageEnd()
2339 
    if result.ex is not None:
2340 
      raise result.ex
2341 
    return
2342 
 
4910 phani.kuma 2343 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2344 
    """
3064 chandransh 2345 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2346 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2347 
 
1408 ankur.sing 2348 
    Parameters:
3064 chandransh 2349 
     - warehouseId
1408 ankur.sing 2350 
     - providerId
3064 chandransh 2351 
     - cod
4910 phani.kuma 2352 
     - orderIds
1408 ankur.sing 2353 
    """
4910 phani.kuma 2354 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2355 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2356 
 
4910 phani.kuma 2357 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2358 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2359 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2360 
    args.warehouseId = warehouseId
1408 ankur.sing 2361 
    args.providerId = providerId
3064 chandransh 2362 
    args.cod = cod
4910 phani.kuma 2363 
    args.orderIds = orderIds
1408 ankur.sing 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
4910 phani.kuma 2368 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 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 = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
3431 rajveer 2378 
    if result.success is not None:
1408 ankur.sing 2379 
      return result.success
3431 rajveer 2380 
    if result.ex is not None:
3064 chandransh 2381 
      raise result.ex
4910 phani.kuma 2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2383 
 
4910 phani.kuma 2384 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2385 
    """
4910 phani.kuma 2386 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2387 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2388 
 
2389 
    Parameters:
2390 
     - providerId
4910 phani.kuma 2391 
     - pickupDetails
4410 rajveer 2392 
    """
4910 phani.kuma 2393 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2394 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2395 
 
4910 phani.kuma 2396 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2397 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2398 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2399 
    args.providerId = providerId
4910 phani.kuma 2400 
    args.pickupDetails = pickupDetails
4410 rajveer 2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
4910 phani.kuma 2405 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
4910 phani.kuma 2412 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
2415 
    if result.ex is not None:
2416 
      raise result.ex
4910 phani.kuma 2417 
    return
4410 rajveer 2418 
 
4910 phani.kuma 2419 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2420 
    """
3064 chandransh 2421 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2422 
 
94 ashish 2423 
    Parameters:
3064 chandransh 2424 
     - providerId
304 ashish 2425 
    """
4910 phani.kuma 2426 
    self.send_getOrdersNotPickedUp(providerId)
2427 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2428 
 
4910 phani.kuma 2429 
  def send_getOrdersNotPickedUp(self, providerId):
2430 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2431 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2432 
    args.providerId = providerId
304 ashish 2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
4910 phani.kuma 2437 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
4910 phani.kuma 2444 
    result = getOrdersNotPickedUp_result()
304 ashish 2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
3431 rajveer 2447 
    if result.success is not None:
304 ashish 2448 
      return result.success
4910 phani.kuma 2449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2450 
 
3064 chandransh 2451 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2452 
    """
3064 chandransh 2453 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2454 
    the name of the receiver.
2455 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2456 
 
304 ashish 2457 
    Parameters:
3064 chandransh 2458 
     - providerId
2459 
     - deliveredOrders
304 ashish 2460 
    """
3064 chandransh 2461 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2462 
    self.recv_markOrdersAsDelivered()
304 ashish 2463 
 
3064 chandransh 2464 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2465 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2466 
    args = markOrdersAsDelivered_args()
2467 
    args.providerId = providerId
2468 
    args.deliveredOrders = deliveredOrders
304 ashish 2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
3064 chandransh 2473 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
3064 chandransh 2480 
    result = markOrdersAsDelivered_result()
304 ashish 2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
3431 rajveer 2483 
    if result.ex is not None:
3064 chandransh 2484 
      raise result.ex
304 ashish 2485 
    return
2486 
 
4910 phani.kuma 2487 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2488 
    """
4910 phani.kuma 2489 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2490 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2491 
 
3064 chandransh 2492 
    Parameters:
2493 
     - providerId
2494 
     - returnedOrders
1596 ankur.sing 2495 
    """
4910 phani.kuma 2496 
    self.send_markAsRTOrders(providerId, returnedOrders)
2497 
    self.recv_markAsRTOrders()
304 ashish 2498 
 
4910 phani.kuma 2499 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2500 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2501 
    args = markAsRTOrders_args()
3064 chandransh 2502 
    args.providerId = providerId
2503 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2504 
    args.write(self._oprot)
2505 
    self._oprot.writeMessageEnd()
2506 
    self._oprot.trans.flush()
2507 
 
4910 phani.kuma 2508 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2510 
    if mtype == TMessageType.EXCEPTION:
2511 
      x = TApplicationException()
2512 
      x.read(self._iprot)
2513 
      self._iprot.readMessageEnd()
2514 
      raise x
4910 phani.kuma 2515 
    result = markAsRTOrders_result()
1596 ankur.sing 2516 
    result.read(self._iprot)
2517 
    self._iprot.readMessageEnd()
3431 rajveer 2518 
    if result.ex is not None:
3064 chandransh 2519 
      raise result.ex
2520 
    return
1596 ankur.sing 2521 
 
4910 phani.kuma 2522 
  def getRTOrders(self, providerId):
2523 
    """
2524 
    Returns a list of orders that were returned by courier.
2525 
 
2526 
    Parameters:
2527 
     - providerId
2528 
    """
2529 
    self.send_getRTOrders(providerId)
2530 
    return self.recv_getRTOrders()
2531 
 
2532 
  def send_getRTOrders(self, providerId):
2533 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2534 
    args = getRTOrders_args()
2535 
    args.providerId = providerId
2536 
    args.write(self._oprot)
2537 
    self._oprot.writeMessageEnd()
2538 
    self._oprot.trans.flush()
2539 
 
2540 
  def recv_getRTOrders(self, ):
2541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2542 
    if mtype == TMessageType.EXCEPTION:
2543 
      x = TApplicationException()
2544 
      x.read(self._iprot)
2545 
      self._iprot.readMessageEnd()
2546 
      raise x
2547 
    result = getRTOrders_result()
2548 
    result.read(self._iprot)
2549 
    self._iprot.readMessageEnd()
2550 
    if result.success is not None:
2551 
      return result.success
2552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2553 
 
3064 chandransh 2554 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2555 
    """
3064 chandransh 2556 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2557 
 
3064 chandransh 2558 
    Parameters:
2559 
     - providerId
2560 
     - undeliveredOrders
1627 ankur.sing 2561 
    """
3064 chandransh 2562 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2563 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2564 
 
3064 chandransh 2565 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2566 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2567 
    args = updateNonDeliveryReason_args()
2568 
    args.providerId = providerId
2569 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
3064 chandransh 2574 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
3064 chandransh 2581 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
4910 phani.kuma 2584 
    if result.ex is not None:
2585 
      raise result.ex
2586 
    return
2587 
 
2588 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2589 
    """
2590 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2591 
 
2592 
    Parameters:
2593 
     - providerId
2594 
    """
2595 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2596 
    return self.recv_getNonDeliveredOrdersbyCourier()
2597 
 
2598 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2599 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2600 
    args = getNonDeliveredOrdersbyCourier_args()
2601 
    args.providerId = providerId
2602 
    args.write(self._oprot)
2603 
    self._oprot.writeMessageEnd()
2604 
    self._oprot.trans.flush()
2605 
 
2606 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2608 
    if mtype == TMessageType.EXCEPTION:
2609 
      x = TApplicationException()
2610 
      x.read(self._iprot)
2611 
      self._iprot.readMessageEnd()
2612 
      raise x
2613 
    result = getNonDeliveredOrdersbyCourier_result()
2614 
    result.read(self._iprot)
2615 
    self._iprot.readMessageEnd()
4581 phani.kuma 2616 
    if result.success is not None:
2617 
      return result.success
4910 phani.kuma 2618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2619 
 
2620 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2621 
    """
2622 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2623 
 
2624 
    Parameters:
2625 
     - providerId
2626 
     - local_connected_orders
2627 
    """
2628 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2629 
    self.recv_markOrdersAsLocalConnected()
2630 
 
2631 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2632 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2633 
    args = markOrdersAsLocalConnected_args()
2634 
    args.providerId = providerId
2635 
    args.local_connected_orders = local_connected_orders
2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
2640 
  def recv_markOrdersAsLocalConnected(self, ):
2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
2647 
    result = markOrdersAsLocalConnected_result()
2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
3431 rajveer 2650 
    if result.ex is not None:
3064 chandransh 2651 
      raise result.ex
4910 phani.kuma 2652 
    return
1627 ankur.sing 2653 
 
4910 phani.kuma 2654 
  def getOrdersNotLocalConnected(self, providerId):
2655 
    """
2656 
    Returns a list of orders that were picked up or shipped but pending local connection.
2657 
 
2658 
    Parameters:
2659 
     - providerId
2660 
    """
2661 
    self.send_getOrdersNotLocalConnected(providerId)
2662 
    return self.recv_getOrdersNotLocalConnected()
2663 
 
2664 
  def send_getOrdersNotLocalConnected(self, providerId):
2665 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2666 
    args = getOrdersNotLocalConnected_args()
2667 
    args.providerId = providerId
2668 
    args.write(self._oprot)
2669 
    self._oprot.writeMessageEnd()
2670 
    self._oprot.trans.flush()
2671 
 
2672 
  def recv_getOrdersNotLocalConnected(self, ):
2673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2674 
    if mtype == TMessageType.EXCEPTION:
2675 
      x = TApplicationException()
2676 
      x.read(self._iprot)
2677 
      self._iprot.readMessageEnd()
2678 
      raise x
2679 
    result = getOrdersNotLocalConnected_result()
2680 
    result.read(self._iprot)
2681 
    self._iprot.readMessageEnd()
2682 
    if result.success is not None:
2683 
      return result.success
2684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2685 
 
2686 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2687 
    """
2688 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2689 
 
2690 
    Parameters:
2691 
     - providerId
2692 
     - destination_city_reached_orders
2693 
    """
2694 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2695 
    self.recv_markOrdersAsDestinationCityReached()
2696 
 
2697 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2698 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2699 
    args = markOrdersAsDestinationCityReached_args()
2700 
    args.providerId = providerId
2701 
    args.destination_city_reached_orders = destination_city_reached_orders
2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2706 
  def recv_markOrdersAsDestinationCityReached(self, ):
2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2713 
    result = markOrdersAsDestinationCityReached_result()
2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
2716 
    if result.ex is not None:
2717 
      raise result.ex
2718 
    return
2719 
 
2720 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2721 
    """
2722 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2723 
 
2724 
    Parameters:
2725 
     - providerId
2726 
     - first_atdl_orders
2727 
    """
2728 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2729 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2730 
 
2731 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2732 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2733 
    args = markOrdersAsFirstDeliveryAttempted_args()
2734 
    args.providerId = providerId
2735 
    args.first_atdl_orders = first_atdl_orders
2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
2740 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
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
2747 
    result = markOrdersAsFirstDeliveryAttempted_result()
2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
2750 
    if result.ex is not None:
2751 
      raise result.ex
2752 
    return
2753 
 
3064 chandransh 2754 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2755 
    """
3064 chandransh 2756 
    Returns the list of orders whose delivery time has passed but have not been
2757 
    delivered yet for the given provider and warehouse. To get a complete list of
2758 
    undelivered orders, pass them as -1.
2759 
    Returns an empty list if no such orders exist.
3431 rajveer 2760 
 
1886 ankur.sing 2761 
    Parameters:
3064 chandransh 2762 
     - providerId
2763 
     - warehouseId
1886 ankur.sing 2764 
    """
3064 chandransh 2765 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2766 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2767 
 
3064 chandransh 2768 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2769 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2770 
    args = getUndeliveredOrders_args()
2771 
    args.providerId = providerId
2772 
    args.warehouseId = warehouseId
1886 ankur.sing 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
3064 chandransh 2777 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
3064 chandransh 2784 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
3431 rajveer 2787 
    if result.success is not None:
1886 ankur.sing 2788 
      return result.success
3064 chandransh 2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2790 
 
4783 phani.kuma 2791 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2792 
    """
2793 
    Returns the list of orders whose expected delivery date has passed but have not been
2794 
    delivered yet.
2795 
    Returns an empty list if no such orders exist.
2796 
    """
2797 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2798 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2799 
 
2800 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2801 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2802 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2803 
    args.write(self._oprot)
2804 
    self._oprot.writeMessageEnd()
2805 
    self._oprot.trans.flush()
2806 
 
2807 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2809 
    if mtype == TMessageType.EXCEPTION:
2810 
      x = TApplicationException()
2811 
      x.read(self._iprot)
2812 
      self._iprot.readMessageEnd()
2813 
      raise x
2814 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2815 
    result.read(self._iprot)
2816 
    self._iprot.readMessageEnd()
2817 
    if result.success is not None:
2818 
      return result.success
2819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2820 
 
2536 chandransh 2821 
  def toggleDOAFlag(self, orderId):
2822 
    """
2823 
    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.
2824 
    Returns the final flag status.
2825 
    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 2826 
 
2536 chandransh 2827 
    Parameters:
2828 
     - orderId
2829 
    """
2830 
    self.send_toggleDOAFlag(orderId)
2831 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2832 
 
2536 chandransh 2833 
  def send_toggleDOAFlag(self, orderId):
2834 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2835 
    args = toggleDOAFlag_args()
2836 
    args.orderId = orderId
2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_toggleDOAFlag(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = toggleDOAFlag_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
3431 rajveer 2851 
    if result.success is not None:
2536 chandransh 2852 
      return result.success
3431 rajveer 2853 
    if result.ex is not None:
2536 chandransh 2854 
      raise result.ex
2855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2856 
 
4712 rajveer 2857 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2858 
    """
2859 
    Parameters:
2860 
     - orderId
2861 
     - deliveryTimestamp
2862 
     - receiver
2863 
    """
2864 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2865 
    self.recv_markOrderAsDelivered()
2866 
 
2867 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2868 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2869 
    args = markOrderAsDelivered_args()
2870 
    args.orderId = orderId
2871 
    args.deliveryTimestamp = deliveryTimestamp
2872 
    args.receiver = receiver
2873 
    args.write(self._oprot)
2874 
    self._oprot.writeMessageEnd()
2875 
    self._oprot.trans.flush()
2876 
 
2877 
  def recv_markOrderAsDelivered(self, ):
2878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2879 
    if mtype == TMessageType.EXCEPTION:
2880 
      x = TApplicationException()
2881 
      x.read(self._iprot)
2882 
      self._iprot.readMessageEnd()
2883 
      raise x
2884 
    result = markOrderAsDelivered_result()
2885 
    result.read(self._iprot)
2886 
    self._iprot.readMessageEnd()
2887 
    if result.ex is not None:
2888 
      raise result.ex
2889 
    return
2890 
 
4454 rajveer 2891 
  def markOrderDoaRequestReceived(self, orderId):
2892 
    """
2893 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2894 
 
2895 
    Parameters:
2896 
     - orderId
2897 
    """
2898 
    self.send_markOrderDoaRequestReceived(orderId)
2899 
    return self.recv_markOrderDoaRequestReceived()
2900 
 
2901 
  def send_markOrderDoaRequestReceived(self, orderId):
2902 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2903 
    args = markOrderDoaRequestReceived_args()
2904 
    args.orderId = orderId
2905 
    args.write(self._oprot)
2906 
    self._oprot.writeMessageEnd()
2907 
    self._oprot.trans.flush()
2908 
 
2909 
  def recv_markOrderDoaRequestReceived(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 = markOrderDoaRequestReceived_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, "markOrderDoaRequestReceived failed: unknown result");
2924 
 
2925 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2926 
    """
2927 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2928 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2929 
 
2930 
    Parameters:
2931 
     - orderId
2932 
     - isAuthorized
2933 
    """
2934 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2935 
    return self.recv_markOrderDoaRequestAuthorized()
2936 
 
2937 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2938 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2939 
    args = markOrderDoaRequestAuthorized_args()
2940 
    args.orderId = orderId
2941 
    args.isAuthorized = isAuthorized
2942 
    args.write(self._oprot)
2943 
    self._oprot.writeMessageEnd()
2944 
    self._oprot.trans.flush()
2945 
 
2946 
  def recv_markOrderDoaRequestAuthorized(self, ):
2947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2948 
    if mtype == TMessageType.EXCEPTION:
2949 
      x = TApplicationException()
2950 
      x.read(self._iprot)
2951 
      self._iprot.readMessageEnd()
2952 
      raise x
2953 
    result = markOrderDoaRequestAuthorized_result()
2954 
    result.read(self._iprot)
2955 
    self._iprot.readMessageEnd()
2956 
    if result.success is not None:
2957 
      return result.success
2958 
    if result.ex is not None:
2959 
      raise result.ex
2960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2961 
 
4488 rajveer 2962 
  def markOrderReturnRequestReceived(self, orderId):
2963 
    """
2964 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2965 
 
2966 
    Parameters:
2967 
     - orderId
2968 
    """
2969 
    self.send_markOrderReturnRequestReceived(orderId)
2970 
    return self.recv_markOrderReturnRequestReceived()
2971 
 
2972 
  def send_markOrderReturnRequestReceived(self, orderId):
2973 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2974 
    args = markOrderReturnRequestReceived_args()
2975 
    args.orderId = orderId
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_markOrderReturnRequestReceived(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 = markOrderReturnRequestReceived_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, "markOrderReturnRequestReceived failed: unknown result");
2995 
 
2996 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2997 
    """
2998 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2999 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3000 
 
3001 
    Parameters:
3002 
     - orderId
3003 
     - isAuthorized
3004 
    """
3005 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3006 
    return self.recv_markOrderReturnRequestAuthorized()
3007 
 
3008 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3009 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3010 
    args = markOrderReturnRequestAuthorized_args()
3011 
    args.orderId = orderId
3012 
    args.isAuthorized = isAuthorized
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_markOrderReturnRequestAuthorized(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = markOrderReturnRequestAuthorized_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
3027 
    if result.success is not None:
3028 
      return result.success
3029 
    if result.ex is not None:
3030 
      raise result.ex
3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3032 
 
4579 rajveer 3033 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3034 
    """
3035 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3036 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3037 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3038 
    For any other status, it returns false.
3039 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3040 
 
2536 chandransh 3041 
    Parameters:
3042 
     - orderId
4579 rajveer 3043 
     - providerId
2536 chandransh 3044 
    """
4579 rajveer 3045 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3046 
    return self.recv_requestPickupNumber()
3047 
 
4579 rajveer 3048 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3049 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3050 
    args = requestPickupNumber_args()
3051 
    args.orderId = orderId
4579 rajveer 3052 
    args.providerId = providerId
2536 chandransh 3053 
    args.write(self._oprot)
3054 
    self._oprot.writeMessageEnd()
3055 
    self._oprot.trans.flush()
3056 
 
3057 
  def recv_requestPickupNumber(self, ):
3058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3059 
    if mtype == TMessageType.EXCEPTION:
3060 
      x = TApplicationException()
3061 
      x.read(self._iprot)
3062 
      self._iprot.readMessageEnd()
3063 
      raise x
3064 
    result = requestPickupNumber_result()
3065 
    result.read(self._iprot)
3066 
    self._iprot.readMessageEnd()
3431 rajveer 3067 
    if result.success is not None:
2536 chandransh 3068 
      return result.success
3431 rajveer 3069 
    if result.ex is not None:
2536 chandransh 3070 
      raise result.ex
3071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3072 
 
4602 rajveer 3073 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3074 
    """
4452 rajveer 3075 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3076 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3077 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3078 
    	3. Returns true
2591 chandransh 3079 
    If the order is in any other status, it returns false.
2536 chandransh 3080 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3081 
 
2536 chandransh 3082 
    Parameters:
3083 
     - orderId
3084 
     - pickupNumber
4602 rajveer 3085 
     - providerId
2536 chandransh 3086 
    """
4602 rajveer 3087 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3088 
    return self.recv_authorizePickup()
3089 
 
4602 rajveer 3090 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3091 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3092 
    args = authorizePickup_args()
3093 
    args.orderId = orderId
3094 
    args.pickupNumber = pickupNumber
4602 rajveer 3095 
    args.providerId = providerId
2536 chandransh 3096 
    args.write(self._oprot)
3097 
    self._oprot.writeMessageEnd()
3098 
    self._oprot.trans.flush()
3099 
 
3100 
  def recv_authorizePickup(self, ):
3101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3102 
    if mtype == TMessageType.EXCEPTION:
3103 
      x = TApplicationException()
3104 
      x.read(self._iprot)
3105 
      self._iprot.readMessageEnd()
3106 
      raise x
3107 
    result = authorizePickup_result()
3108 
    result.read(self._iprot)
3109 
    self._iprot.readMessageEnd()
3431 rajveer 3110 
    if result.success is not None:
2536 chandransh 3111 
      return result.success
3431 rajveer 3112 
    if result.ex is not None:
2536 chandransh 3113 
      raise result.ex
3114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3115 
 
2764 chandransh 3116 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3117 
    """
3118 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3119 
 
2764 chandransh 3120 
    Parameters:
3121 
     - providerId
3122 
     - pickupDetails
3123 
    """
3124 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3125 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3126 
 
3127 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3128 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3129 
    args = markDoasAsPickedUp_args()
3130 
    args.providerId = providerId
3131 
    args.pickupDetails = pickupDetails
3132 
    args.write(self._oprot)
3133 
    self._oprot.writeMessageEnd()
3134 
    self._oprot.trans.flush()
3135 
 
3136 
  def recv_markDoasAsPickedUp(self, ):
3137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3138 
    if mtype == TMessageType.EXCEPTION:
3139 
      x = TApplicationException()
3140 
      x.read(self._iprot)
3141 
      self._iprot.readMessageEnd()
3142 
      raise x
3143 
    result = markDoasAsPickedUp_result()
3144 
    result.read(self._iprot)
3145 
    self._iprot.readMessageEnd()
4910 phani.kuma 3146 
    return
3147 
 
3148 
  def getDoasNotPickedUp(self, providerId):
3149 
    """
3150 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3151 
 
3152 
    Parameters:
3153 
     - providerId
3154 
    """
3155 
    self.send_getDoasNotPickedUp(providerId)
3156 
    return self.recv_getDoasNotPickedUp()
3157 
 
3158 
  def send_getDoasNotPickedUp(self, providerId):
3159 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3160 
    args = getDoasNotPickedUp_args()
3161 
    args.providerId = providerId
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_getDoasNotPickedUp(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = getDoasNotPickedUp_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3431 rajveer 3176 
    if result.success is not None:
2764 chandransh 3177 
      return result.success
4910 phani.kuma 3178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3179 
 
4741 phani.kuma 3180 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3181 
    """
3182 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3183 
 
3184 
    Parameters:
3185 
     - providerId
3186 
     - pickupDetails
3187 
    """
3188 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3189 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3190 
 
3191 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3192 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3193 
    args = markReturnOrdersAsPickedUp_args()
3194 
    args.providerId = providerId
3195 
    args.pickupDetails = pickupDetails
3196 
    args.write(self._oprot)
3197 
    self._oprot.writeMessageEnd()
3198 
    self._oprot.trans.flush()
3199 
 
3200 
  def recv_markReturnOrdersAsPickedUp(self, ):
3201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3202 
    if mtype == TMessageType.EXCEPTION:
3203 
      x = TApplicationException()
3204 
      x.read(self._iprot)
3205 
      self._iprot.readMessageEnd()
3206 
      raise x
3207 
    result = markReturnOrdersAsPickedUp_result()
3208 
    result.read(self._iprot)
3209 
    self._iprot.readMessageEnd()
4910 phani.kuma 3210 
    return
3211 
 
3212 
  def getReturnOrdersNotPickedUp(self, providerId):
3213 
    """
3214 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3215 
 
3216 
    Parameters:
3217 
     - providerId
3218 
    """
3219 
    self.send_getReturnOrdersNotPickedUp(providerId)
3220 
    return self.recv_getReturnOrdersNotPickedUp()
3221 
 
3222 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3223 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3224 
    args = getReturnOrdersNotPickedUp_args()
3225 
    args.providerId = providerId
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_getReturnOrdersNotPickedUp(self, ):
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
3237 
    result = getReturnOrdersNotPickedUp_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
4741 phani.kuma 3240 
    if result.success is not None:
3241 
      return result.success
4910 phani.kuma 3242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3243 
 
4479 rajveer 3244 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3245 
    """
4452 rajveer 3246 
    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 3247 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3248 
    If the order is in any other state, it returns false.
3249 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3250 
 
2591 chandransh 3251 
    Parameters:
3252 
     - orderId
4479 rajveer 3253 
     - receiveCondition
2591 chandransh 3254 
    """
4479 rajveer 3255 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3256 
    return self.recv_receiveReturn()
2536 chandransh 3257 
 
4479 rajveer 3258 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3259 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3260 
    args = receiveReturn_args()
2591 chandransh 3261 
    args.orderId = orderId
4479 rajveer 3262 
    args.receiveCondition = receiveCondition
2591 chandransh 3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
2616 chandransh 3267 
  def recv_receiveReturn(self, ):
2591 chandransh 3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
2616 chandransh 3274 
    result = receiveReturn_result()
2591 chandransh 3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
3431 rajveer 3277 
    if result.success is not None:
2591 chandransh 3278 
      return result.success
3431 rajveer 3279 
    if result.ex is not None:
2591 chandransh 3280 
      raise result.ex
2616 chandransh 3281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3282 
 
3283 
  def validateDoa(self, orderId, isValid):
3284 
    """
4452 rajveer 3285 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3286 
    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 3287 
    If the order is in any other state, it returns false.
3288 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3289 
 
2591 chandransh 3290 
    Parameters:
3291 
     - orderId
3292 
     - isValid
3293 
    """
3294 
    self.send_validateDoa(orderId, isValid)
3295 
    return self.recv_validateDoa()
3296 
 
3297 
  def send_validateDoa(self, orderId, isValid):
3298 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3299 
    args = validateDoa_args()
3300 
    args.orderId = orderId
3301 
    args.isValid = isValid
3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
3306 
  def recv_validateDoa(self, ):
3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
3313 
    result = validateDoa_result()
3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3431 rajveer 3316 
    if result.success is not None:
2591 chandransh 3317 
      return result.success
3431 rajveer 3318 
    if result.ex is not None:
2591 chandransh 3319 
      raise result.ex
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3321 
 
4495 rajveer 3322 
  def validateReturnProduct(self, orderId, isUsable):
3323 
    """
3324 
    Parameters:
3325 
     - orderId
3326 
     - isUsable
3327 
    """
3328 
    self.send_validateReturnProduct(orderId, isUsable)
3329 
    return self.recv_validateReturnProduct()
3330 
 
3331 
  def send_validateReturnProduct(self, orderId, isUsable):
3332 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3333 
    args = validateReturnProduct_args()
3334 
    args.orderId = orderId
3335 
    args.isUsable = isUsable
3336 
    args.write(self._oprot)
3337 
    self._oprot.writeMessageEnd()
3338 
    self._oprot.trans.flush()
3339 
 
3340 
  def recv_validateReturnProduct(self, ):
3341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3342 
    if mtype == TMessageType.EXCEPTION:
3343 
      x = TApplicationException()
3344 
      x.read(self._iprot)
3345 
      self._iprot.readMessageEnd()
3346 
      raise x
3347 
    result = validateReturnProduct_result()
3348 
    result.read(self._iprot)
3349 
    self._iprot.readMessageEnd()
3350 
    if result.success is not None:
3351 
      return result.success
3352 
    if result.ex is not None:
3353 
      raise result.ex
3354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3355 
 
2616 chandransh 3356 
  def reshipOrder(self, orderId):
3357 
    """
4484 rajveer 3358 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3359 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3360 
    	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 3361 
 
3362 
    If the order is in DOA_CERT_VALID state, it does the following:
3363 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3364 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3365 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3366 
 
2616 chandransh 3367 
    Returns the id of the newly created order.
3431 rajveer 3368 
 
2616 chandransh 3369 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3370 
 
2616 chandransh 3371 
    Parameters:
3372 
     - orderId
3373 
    """
3374 
    self.send_reshipOrder(orderId)
3375 
    return self.recv_reshipOrder()
2591 chandransh 3376 
 
2616 chandransh 3377 
  def send_reshipOrder(self, orderId):
3378 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3379 
    args = reshipOrder_args()
3380 
    args.orderId = orderId
3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_reshipOrder(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = reshipOrder_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
3431 rajveer 3395 
    if result.success is not None:
2616 chandransh 3396 
      return result.success
3431 rajveer 3397 
    if result.ex is not None:
2616 chandransh 3398 
      raise result.ex
3399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3400 
 
3226 chandransh 3401 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3402 
    """
4484 rajveer 3403 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3404 
    	1. Creates a refund request for batch processing.
3405 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3406 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3407 
 
2616 chandransh 3408 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3409 
    	1. Creates a refund request for batch processing.
3226 chandransh 3410 
    	2. Cancels the reservation of the item in the warehouse.
3411 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3412 
 
3226 chandransh 3413 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3414 
    	1. Cancels the reservation of the item in the warehouse.
3415 
    	2. Marks the current order as CANCELED.
3416 
 
3417 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3418 
 
2616 chandransh 3419 
    Returns True if it is successful, False otherwise.
3431 rajveer 3420 
 
2616 chandransh 3421 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3422 
 
2616 chandransh 3423 
    Parameters:
3424 
     - orderId
3226 chandransh 3425 
     - refundedBy
3426 
     - reason
2616 chandransh 3427 
    """
3226 chandransh 3428 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3429 
    return self.recv_refundOrder()
3430 
 
3226 chandransh 3431 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3432 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3433 
    args = refundOrder_args()
3434 
    args.orderId = orderId
3226 chandransh 3435 
    args.refundedBy = refundedBy
3436 
    args.reason = reason
2616 chandransh 3437 
    args.write(self._oprot)
3438 
    self._oprot.writeMessageEnd()
3439 
    self._oprot.trans.flush()
3440 
 
3441 
  def recv_refundOrder(self, ):
3442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3443 
    if mtype == TMessageType.EXCEPTION:
3444 
      x = TApplicationException()
3445 
      x.read(self._iprot)
3446 
      self._iprot.readMessageEnd()
3447 
      raise x
3448 
    result = refundOrder_result()
3449 
    result.read(self._iprot)
3450 
    self._iprot.readMessageEnd()
3431 rajveer 3451 
    if result.success is not None:
2616 chandransh 3452 
      return result.success
3431 rajveer 3453 
    if result.ex is not None:
2616 chandransh 3454 
      raise result.ex
3455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3456 
 
2690 chandransh 3457 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3458 
    """
3459 
    Get all return orders created between the from and to dates for the given warehouse.
3460 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3461 
 
2690 chandransh 3462 
    Parameters:
3463 
     - warehouseId
3464 
     - fromDate
3465 
     - toDate
3466 
    """
3467 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3468 
    return self.recv_getReturnOrders()
2616 chandransh 3469 
 
2690 chandransh 3470 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3471 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3472 
    args = getReturnOrders_args()
3473 
    args.warehouseId = warehouseId
3474 
    args.fromDate = fromDate
3475 
    args.toDate = toDate
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_getReturnOrders(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = getReturnOrders_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3431 rajveer 3490 
    if result.success is not None:
2690 chandransh 3491 
      return result.success
3492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3493 
 
2700 chandransh 3494 
  def getReturnOrder(self, id):
3495 
    """
3496 
    Returns the ReturnOrder corresponding to the given id.
3497 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3498 
 
2700 chandransh 3499 
    Parameters:
3500 
     - id
3501 
    """
3502 
    self.send_getReturnOrder(id)
3503 
    return self.recv_getReturnOrder()
3504 
 
3505 
  def send_getReturnOrder(self, id):
3506 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3507 
    args = getReturnOrder_args()
3508 
    args.id = id
3509 
    args.write(self._oprot)
3510 
    self._oprot.writeMessageEnd()
3511 
    self._oprot.trans.flush()
3512 
 
3513 
  def recv_getReturnOrder(self, ):
3514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3515 
    if mtype == TMessageType.EXCEPTION:
3516 
      x = TApplicationException()
3517 
      x.read(self._iprot)
3518 
      self._iprot.readMessageEnd()
3519 
      raise x
3520 
    result = getReturnOrder_result()
3521 
    result.read(self._iprot)
3522 
    self._iprot.readMessageEnd()
3431 rajveer 3523 
    if result.success is not None:
2700 chandransh 3524 
      return result.success
3431 rajveer 3525 
    if result.ex is not None:
2700 chandransh 3526 
      raise result.ex
3527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3528 
 
2690 chandransh 3529 
  def processReturn(self, returnOrderId):
3530 
    """
3531 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3532 
 
2690 chandransh 3533 
    Parameters:
3534 
     - returnOrderId
3535 
    """
3536 
    self.send_processReturn(returnOrderId)
3537 
    self.recv_processReturn()
3538 
 
3539 
  def send_processReturn(self, returnOrderId):
3540 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3541 
    args = processReturn_args()
3542 
    args.returnOrderId = returnOrderId
3543 
    args.write(self._oprot)
3544 
    self._oprot.writeMessageEnd()
3545 
    self._oprot.trans.flush()
3546 
 
3547 
  def recv_processReturn(self, ):
3548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3549 
    if mtype == TMessageType.EXCEPTION:
3550 
      x = TApplicationException()
3551 
      x.read(self._iprot)
3552 
      self._iprot.readMessageEnd()
3553 
      raise x
3554 
    result = processReturn_result()
3555 
    result.read(self._iprot)
3556 
    self._iprot.readMessageEnd()
3431 rajveer 3557 
    if result.ex is not None:
2690 chandransh 3558 
      raise result.ex
3559 
    return
3560 
 
3451 chandransh 3561 
  def updateWeight(self, orderId, weight):
3562 
    """
3563 
    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 3564 
 
3451 chandransh 3565 
    Parameters:
3566 
     - orderId
3567 
     - weight
3568 
    """
3569 
    self.send_updateWeight(orderId, weight)
3570 
    return self.recv_updateWeight()
3571 
 
3572 
  def send_updateWeight(self, orderId, weight):
3573 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3574 
    args = updateWeight_args()
3575 
    args.orderId = orderId
3576 
    args.weight = weight
3577 
    args.write(self._oprot)
3578 
    self._oprot.writeMessageEnd()
3579 
    self._oprot.trans.flush()
3580 
 
3581 
  def recv_updateWeight(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 = updateWeight_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, "updateWeight failed: unknown result");
3596 
 
3469 chandransh 3597 
  def changeItem(self, orderId, itemId):
3598 
    """
3599 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3600 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3601 
 
3469 chandransh 3602 
    Parameters:
3603 
     - orderId
3604 
     - itemId
3605 
    """
3606 
    self.send_changeItem(orderId, itemId)
3607 
    return self.recv_changeItem()
3608 
 
3609 
  def send_changeItem(self, orderId, itemId):
3610 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3611 
    args = changeItem_args()
3612 
    args.orderId = orderId
3613 
    args.itemId = itemId
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_changeItem(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = changeItem_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
3628 
    if result.success is not None:
3629 
      return result.success
3630 
    if result.ex is not None:
3631 
      raise result.ex
3632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3633 
 
3634 
  def shiftToWarehouse(self, orderId, warehouseId):
3635 
    """
3636 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3637 
 
3638 
    Parameters:
3639 
     - orderId
3640 
     - warehouseId
3641 
    """
3642 
    self.send_shiftToWarehouse(orderId, warehouseId)
3643 
    return self.recv_shiftToWarehouse()
3644 
 
3645 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3646 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3647 
    args = shiftToWarehouse_args()
3648 
    args.orderId = orderId
3649 
    args.warehouseId = warehouseId
3650 
    args.write(self._oprot)
3651 
    self._oprot.writeMessageEnd()
3652 
    self._oprot.trans.flush()
3653 
 
3654 
  def recv_shiftToWarehouse(self, ):
3655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3656 
    if mtype == TMessageType.EXCEPTION:
3657 
      x = TApplicationException()
3658 
      x.read(self._iprot)
3659 
      self._iprot.readMessageEnd()
3660 
      raise x
3661 
    result = shiftToWarehouse_result()
3662 
    result.read(self._iprot)
3663 
    self._iprot.readMessageEnd()
3664 
    if result.success is not None:
3665 
      return result.success
3666 
    if result.ex is not None:
3667 
      raise result.ex
3668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3669 
 
4647 rajveer 3670 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3671 
    """
3672 
    Adds the given delay reason to the given order.
3986 chandransh 3673 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3674 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3675 
 
3553 chandransh 3676 
    Parameters:
3677 
     - orderId
3678 
     - delayReason
3986 chandransh 3679 
     - furtherDelay
4647 rajveer 3680 
     - delayReasonText
3553 chandransh 3681 
    """
4647 rajveer 3682 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3683 
    return self.recv_addDelayReason()
3684 
 
4647 rajveer 3685 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3686 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3687 
    args = addDelayReason_args()
3688 
    args.orderId = orderId
3689 
    args.delayReason = delayReason
3986 chandransh 3690 
    args.furtherDelay = furtherDelay
4647 rajveer 3691 
    args.delayReasonText = delayReasonText
3553 chandransh 3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_addDelayReason(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = addDelayReason_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
3706 
    if result.success is not None:
3707 
      return result.success
3708 
    if result.ex is not None:
3709 
      raise result.ex
3710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3711 
 
3956 chandransh 3712 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3713 
    """
3714 
    Marks the COD orders with given AWB nos. as having been processed.
3715 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3716 
 
3956 chandransh 3717 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3718 
    1. There is no order corresponding to an AWB number.
3719 
    2. The captured amount for a payment exceeds the total payment.
3720 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3721 
 
3722 
    Parameters:
3723 
     - collectedAmountMap
3724 
     - xferBy
3725 
     - xferTxnId
3726 
     - xferDate
3727 
    """
3728 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3729 
    return self.recv_reconcileCodCollection()
3730 
 
3731 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3732 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3733 
    args = reconcileCodCollection_args()
3734 
    args.collectedAmountMap = collectedAmountMap
3735 
    args.xferBy = xferBy
3736 
    args.xferTxnId = xferTxnId
3737 
    args.xferDate = xferDate
3738 
    args.write(self._oprot)
3739 
    self._oprot.writeMessageEnd()
3740 
    self._oprot.trans.flush()
3741 
 
3742 
  def recv_reconcileCodCollection(self, ):
3743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3744 
    if mtype == TMessageType.EXCEPTION:
3745 
      x = TApplicationException()
3746 
      x.read(self._iprot)
3747 
      self._iprot.readMessageEnd()
3748 
      raise x
3749 
    result = reconcileCodCollection_result()
3750 
    result.read(self._iprot)
3751 
    self._iprot.readMessageEnd()
3752 
    if result.success is not None:
3753 
      return result.success
3754 
    if result.ex is not None:
3755 
      raise result.ex
3756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3757 
 
4008 mandeep.dh 3758 
  def getTransactionsRequiringExtraProcessing(self, category):
3759 
    """
4065 mandeep.dh 3760 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3761 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3762 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3763 
 
4008 mandeep.dh 3764 
    Parameters:
3765 
     - category
3766 
    """
3767 
    self.send_getTransactionsRequiringExtraProcessing(category)
3768 
    return self.recv_getTransactionsRequiringExtraProcessing()
3769 
 
3770 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3771 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3772 
    args = getTransactionsRequiringExtraProcessing_args()
3773 
    args.category = category
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_getTransactionsRequiringExtraProcessing(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 = getTransactionsRequiringExtraProcessing_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3788 
    if result.success is not None:
3789 
      return result.success
3790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3791 
 
3792 
  def markTransactionAsProcessed(self, transactionId, category):
3793 
    """
3794 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3795 
    It essentially deletes the transaction id record for a particular
3796 
    processing type category (if present) from DB.
3797 
    This is currently used by CRM application.
4008 mandeep.dh 3798 
 
3799 
    Parameters:
3800 
     - transactionId
3801 
     - category
3802 
    """
3803 
    self.send_markTransactionAsProcessed(transactionId, category)
3804 
    self.recv_markTransactionAsProcessed()
3805 
 
3806 
  def send_markTransactionAsProcessed(self, transactionId, category):
3807 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3808 
    args = markTransactionAsProcessed_args()
3809 
    args.transactionId = transactionId
3810 
    args.category = category
3811 
    args.write(self._oprot)
3812 
    self._oprot.writeMessageEnd()
3813 
    self._oprot.trans.flush()
3814 
 
3815 
  def recv_markTransactionAsProcessed(self, ):
3816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3817 
    if mtype == TMessageType.EXCEPTION:
3818 
      x = TApplicationException()
3819 
      x.read(self._iprot)
3820 
      self._iprot.readMessageEnd()
3821 
      raise x
3822 
    result = markTransactionAsProcessed_result()
3823 
    result.read(self._iprot)
3824 
    self._iprot.readMessageEnd()
3825 
    return
3826 
 
4018 chandransh 3827 
  def getItemWiseRiskyOrdersCount(self, ):
3828 
    """
3829 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3830 
    is defined as one whose shipping date is about to expire.
3831 
    """
3832 
    self.send_getItemWiseRiskyOrdersCount()
3833 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3834 
 
4018 chandransh 3835 
  def send_getItemWiseRiskyOrdersCount(self, ):
3836 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3837 
    args = getItemWiseRiskyOrdersCount_args()
3838 
    args.write(self._oprot)
3839 
    self._oprot.writeMessageEnd()
3840 
    self._oprot.trans.flush()
3841 
 
3842 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3844 
    if mtype == TMessageType.EXCEPTION:
3845 
      x = TApplicationException()
3846 
      x.read(self._iprot)
3847 
      self._iprot.readMessageEnd()
3848 
      raise x
3849 
    result = getItemWiseRiskyOrdersCount_result()
3850 
    result.read(self._iprot)
3851 
    self._iprot.readMessageEnd()
3852 
    if result.success is not None:
3853 
      return result.success
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3855 
 
4295 varun.gupt 3856 
  def getOrdersForItemIds(self, itemIds):
3857 
    """
3858 
    Returns a list of all orders which have items with given id
3859 
 
3860 
    Parameters:
3861 
     - itemIds
3862 
    """
3863 
    self.send_getOrdersForItemIds(itemIds)
3864 
    return self.recv_getOrdersForItemIds()
3865 
 
3866 
  def send_getOrdersForItemIds(self, itemIds):
3867 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3868 
    args = getOrdersForItemIds_args()
3869 
    args.itemIds = itemIds
3870 
    args.write(self._oprot)
3871 
    self._oprot.writeMessageEnd()
3872 
    self._oprot.trans.flush()
3873 
 
3874 
  def recv_getOrdersForItemIds(self, ):
3875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3876 
    if mtype == TMessageType.EXCEPTION:
3877 
      x = TApplicationException()
3878 
      x.read(self._iprot)
3879 
      self._iprot.readMessageEnd()
3880 
      raise x
3881 
    result = getOrdersForItemIds_result()
3882 
    result.read(self._iprot)
3883 
    self._iprot.readMessageEnd()
3884 
    if result.success is not None:
3885 
      return result.success
3886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3887 
 
4247 rajveer 3888 
  def markOrderCancellationRequestReceived(self, orderId):
3889 
    """
3890 
    Mark order as cancellation request received. If customer sends request of cancellation of
3891 
    a particular order, this method will be called. It will just change status of the order
3892 
    depending on its current status. It also records the previous status, so that we can move
3893 
    back to that status if cancellation request is denied.
4018 chandransh 3894 
 
4247 rajveer 3895 
    Parameters:
3896 
     - orderId
3897 
    """
3898 
    self.send_markOrderCancellationRequestReceived(orderId)
3899 
    self.recv_markOrderCancellationRequestReceived()
3900 
 
3901 
  def send_markOrderCancellationRequestReceived(self, orderId):
3902 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3903 
    args = markOrderCancellationRequestReceived_args()
3904 
    args.orderId = orderId
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_markOrderCancellationRequestReceived(self, ):
3910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3911 
    if mtype == TMessageType.EXCEPTION:
3912 
      x = TApplicationException()
3913 
      x.read(self._iprot)
3914 
      self._iprot.readMessageEnd()
3915 
      raise x
3916 
    result = markOrderCancellationRequestReceived_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3919 
    if result.ex is not None:
3920 
      raise result.ex
3921 
    return
3922 
 
3923 
  def markOrderCancellationRequestConfirmed(self, orderId):
3924 
    """
3925 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3926 
    cancellation request confirmed. After this OM will be able to cancel the order.
3927 
 
3928 
    Parameters:
3929 
     - orderId
3930 
    """
3931 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3932 
    self.recv_markOrderCancellationRequestConfirmed()
3933 
 
3934 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3935 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3936 
    args = markOrderCancellationRequestConfirmed_args()
3937 
    args.orderId = orderId
3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
3942 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
3949 
    result = markOrderCancellationRequestConfirmed_result()
3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3952 
    if result.ex is not None:
3953 
      raise result.ex
3954 
    return
3955 
 
3956 
  def markOrderCancellationRequestDenied(self, orderId):
3957 
    """
3958 
    If we decide to not to cancel order, we will move the order ro previous status.
3959 
 
3960 
    Parameters:
3961 
     - orderId
3962 
    """
3963 
    self.send_markOrderCancellationRequestDenied(orderId)
3964 
    self.recv_markOrderCancellationRequestDenied()
3965 
 
3966 
  def send_markOrderCancellationRequestDenied(self, orderId):
3967 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3968 
    args = markOrderCancellationRequestDenied_args()
3969 
    args.orderId = orderId
3970 
    args.write(self._oprot)
3971 
    self._oprot.writeMessageEnd()
3972 
    self._oprot.trans.flush()
3973 
 
3974 
  def recv_markOrderCancellationRequestDenied(self, ):
3975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3976 
    if mtype == TMessageType.EXCEPTION:
3977 
      x = TApplicationException()
3978 
      x.read(self._iprot)
3979 
      self._iprot.readMessageEnd()
3980 
      raise x
3981 
    result = markOrderCancellationRequestDenied_result()
3982 
    result.read(self._iprot)
3983 
    self._iprot.readMessageEnd()
3984 
    if result.ex is not None:
3985 
      raise result.ex
3986 
    return
3987 
 
4258 rajveer 3988 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3989 
    """
4258 rajveer 3990 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3991 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3992 
 
3993 
    Parameters:
4258 rajveer 3994 
     - transactionId
4247 rajveer 3995 
    """
4258 rajveer 3996 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3997 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3998 
 
4258 rajveer 3999 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4000 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4001 
    args = markTransactionAsPaymentFlagRemoved_args()
4002 
    args.transactionId = transactionId
4247 rajveer 4003 
    args.write(self._oprot)
4004 
    self._oprot.writeMessageEnd()
4005 
    self._oprot.trans.flush()
4006 
 
4258 rajveer 4007 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 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
4258 rajveer 4014 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4015 
    result.read(self._iprot)
4016 
    self._iprot.readMessageEnd()
4017 
    if result.ex is not None:
4018 
      raise result.ex
4019 
    return
4020 
 
4259 anupam.sin 4021 
  def refundTransaction(self, transactionId, refundedBy, reason):
4022 
    """
4023 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4024 
    need to be cancelled
4247 rajveer 4025 
 
4259 anupam.sin 4026 
    Parameters:
4027 
     - transactionId
4028 
     - refundedBy
4029 
     - reason
4030 
    """
4031 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4032 
    self.recv_refundTransaction()
4033 
 
4034 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4035 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4036 
    args = refundTransaction_args()
4037 
    args.transactionId = transactionId
4038 
    args.refundedBy = refundedBy
4039 
    args.reason = reason
4040 
    args.write(self._oprot)
4041 
    self._oprot.writeMessageEnd()
4042 
    self._oprot.trans.flush()
4043 
 
4044 
  def recv_refundTransaction(self, ):
4045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4046 
    if mtype == TMessageType.EXCEPTION:
4047 
      x = TApplicationException()
4048 
      x.read(self._iprot)
4049 
      self._iprot.readMessageEnd()
4050 
      raise x
4051 
    result = refundTransaction_result()
4052 
    result.read(self._iprot)
4053 
    self._iprot.readMessageEnd()
4054 
    if result.ex is not None:
4055 
      raise result.ex
4056 
    return
4057 
 
4324 mandeep.dh 4058 
  def updateShipmentAddress(self, orderId, addressId):
4059 
    """
4060 
    Updates shipment address of an order. Delivery and shipping date estimates
4061 
    etc. are also updated here.
4062 
 
4063 
    Throws TransactionServiceException in case address change is not
4064 
    possible due to certain reasons such as new pincode in address is
4065 
    not serviceable etc.
4066 
 
4067 
    Parameters:
4068 
     - orderId
4069 
     - addressId
4070 
    """
4071 
    self.send_updateShipmentAddress(orderId, addressId)
4072 
    self.recv_updateShipmentAddress()
4073 
 
4074 
  def send_updateShipmentAddress(self, orderId, addressId):
4075 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4076 
    args = updateShipmentAddress_args()
4077 
    args.orderId = orderId
4078 
    args.addressId = addressId
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_updateShipmentAddress(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = updateShipmentAddress_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
4093 
    if result.ex is not None:
4094 
      raise result.ex
4095 
    return
4096 
 
4285 rajveer 4097 
  def acceptOrdersForItemId(self, itemId, inventory):
4098 
    """
4099 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4100 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4101 
 
4285 rajveer 4102 
    Parameters:
4103 
     - itemId
4104 
     - inventory
4105 
    """
4106 
    self.send_acceptOrdersForItemId(itemId, inventory)
4107 
    return self.recv_acceptOrdersForItemId()
4108 
 
4109 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4110 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4111 
    args = acceptOrdersForItemId_args()
4112 
    args.itemId = itemId
4113 
    args.inventory = inventory
4114 
    args.write(self._oprot)
4115 
    self._oprot.writeMessageEnd()
4116 
    self._oprot.trans.flush()
4117 
 
4118 
  def recv_acceptOrdersForItemId(self, ):
4119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4120 
    if mtype == TMessageType.EXCEPTION:
4121 
      x = TApplicationException()
4122 
      x.read(self._iprot)
4123 
      self._iprot.readMessageEnd()
4124 
      raise x
4125 
    result = acceptOrdersForItemId_result()
4126 
    result.read(self._iprot)
4127 
    self._iprot.readMessageEnd()
4128 
    if result.success is not None:
4129 
      return result.success
4130 
    if result.ex is not None:
4131 
      raise result.ex
4132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4133 
 
4369 rajveer 4134 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4135 
    """
4136 
    Parameters:
4137 
     - vendorId
4138 
     - itemId
4139 
     - quantity
4140 
     - estimate
4369 rajveer 4141 
     - isReminder
4303 rajveer 4142 
    """
4369 rajveer 4143 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4144 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4145 
 
4369 rajveer 4146 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4147 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4148 
    args = markOrdersAsPORaised_args()
4149 
    args.vendorId = vendorId
4150 
    args.itemId = itemId
4151 
    args.quantity = quantity
4152 
    args.estimate = estimate
4369 rajveer 4153 
    args.isReminder = isReminder
4303 rajveer 4154 
    args.write(self._oprot)
4155 
    self._oprot.writeMessageEnd()
4156 
    self._oprot.trans.flush()
4157 
 
4158 
  def recv_markOrdersAsPORaised(self, ):
4159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4160 
    if mtype == TMessageType.EXCEPTION:
4161 
      x = TApplicationException()
4162 
      x.read(self._iprot)
4163 
      self._iprot.readMessageEnd()
4164 
      raise x
4165 
    result = markOrdersAsPORaised_result()
4166 
    result.read(self._iprot)
4167 
    self._iprot.readMessageEnd()
4168 
    if result.ex is not None:
4169 
      raise result.ex
4170 
    return
4171 
 
4369 rajveer 4172 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4173 
    """
4174 
    Parameters:
4175 
     - vendorId
4176 
     - itemId
4177 
     - quantity
4178 
     - estimate
4369 rajveer 4179 
     - isReminder
4303 rajveer 4180 
    """
4369 rajveer 4181 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4182 
    self.recv_markOrdersAsReversalInitiated()
4183 
 
4369 rajveer 4184 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4185 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4186 
    args = markOrdersAsReversalInitiated_args()
4187 
    args.vendorId = vendorId
4188 
    args.itemId = itemId
4189 
    args.quantity = quantity
4190 
    args.estimate = estimate
4369 rajveer 4191 
    args.isReminder = isReminder
4303 rajveer 4192 
    args.write(self._oprot)
4193 
    self._oprot.writeMessageEnd()
4194 
    self._oprot.trans.flush()
4195 
 
4196 
  def recv_markOrdersAsReversalInitiated(self, ):
4197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4198 
    if mtype == TMessageType.EXCEPTION:
4199 
      x = TApplicationException()
4200 
      x.read(self._iprot)
4201 
      self._iprot.readMessageEnd()
4202 
      raise x
4203 
    result = markOrdersAsReversalInitiated_result()
4204 
    result.read(self._iprot)
4205 
    self._iprot.readMessageEnd()
4206 
    if result.ex is not None:
4207 
      raise result.ex
4208 
    return
4209 
 
4369 rajveer 4210 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4211 
    """
4212 
    Parameters:
4213 
     - vendorId
4214 
     - itemId
4215 
     - quantity
4216 
     - estimate
4369 rajveer 4217 
     - isReminder
4303 rajveer 4218 
    """
4369 rajveer 4219 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4220 
    self.recv_markOrdersAsNotAvailabke()
4221 
 
4369 rajveer 4222 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4223 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4224 
    args = markOrdersAsNotAvailabke_args()
4225 
    args.vendorId = vendorId
4226 
    args.itemId = itemId
4227 
    args.quantity = quantity
4228 
    args.estimate = estimate
4369 rajveer 4229 
    args.isReminder = isReminder
4303 rajveer 4230 
    args.write(self._oprot)
4231 
    self._oprot.writeMessageEnd()
4232 
    self._oprot.trans.flush()
4233 
 
4234 
  def recv_markOrdersAsNotAvailabke(self, ):
4235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4236 
    if mtype == TMessageType.EXCEPTION:
4237 
      x = TApplicationException()
4238 
      x.read(self._iprot)
4239 
      self._iprot.readMessageEnd()
4240 
      raise x
4241 
    result = markOrdersAsNotAvailabke_result()
4242 
    result.read(self._iprot)
4243 
    self._iprot.readMessageEnd()
4244 
    if result.ex is not None:
4245 
      raise result.ex
4246 
    return
4247 
 
4369 rajveer 4248 
  def markOrdersAsTimeout(self, vendorId):
4249 
    """
4250 
    Parameters:
4251 
     - vendorId
4252 
    """
4253 
    self.send_markOrdersAsTimeout(vendorId)
4254 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4255 
 
4369 rajveer 4256 
  def send_markOrdersAsTimeout(self, vendorId):
4257 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4258 
    args = markOrdersAsTimeout_args()
4259 
    args.vendorId = vendorId
4260 
    args.write(self._oprot)
4261 
    self._oprot.writeMessageEnd()
4262 
    self._oprot.trans.flush()
4263 
 
4264 
  def recv_markOrdersAsTimeout(self, ):
4265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4266 
    if mtype == TMessageType.EXCEPTION:
4267 
      x = TApplicationException()
4268 
      x.read(self._iprot)
4269 
      self._iprot.readMessageEnd()
4270 
      raise x
4271 
    result = markOrdersAsTimeout_result()
4272 
    result.read(self._iprot)
4273 
    self._iprot.readMessageEnd()
4274 
    if result.success is not None:
4275 
      return result.success
4276 
    if result.ex is not None:
4277 
      raise result.ex
4278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4279 
 
4662 rajveer 4280 
  def markOrderAsLostInTransit(self, orderId):
4281 
    """
4282 
    Mark order as LOST_IN_TRANSIT
4283 
 
4284 
    Parameters:
4285 
     - orderId
4286 
    """
4287 
    self.send_markOrderAsLostInTransit(orderId)
4288 
    return self.recv_markOrderAsLostInTransit()
4289 
 
4290 
  def send_markOrderAsLostInTransit(self, orderId):
4291 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4292 
    args = markOrderAsLostInTransit_args()
4293 
    args.orderId = orderId
4294 
    args.write(self._oprot)
4295 
    self._oprot.writeMessageEnd()
4296 
    self._oprot.trans.flush()
4297 
 
4298 
  def recv_markOrderAsLostInTransit(self, ):
4299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4300 
    if mtype == TMessageType.EXCEPTION:
4301 
      x = TApplicationException()
4302 
      x.read(self._iprot)
4303 
      self._iprot.readMessageEnd()
4304 
      raise x
4305 
    result = markOrderAsLostInTransit_result()
4306 
    result.read(self._iprot)
4307 
    self._iprot.readMessageEnd()
4308 
    if result.success is not None:
4309 
      return result.success
4310 
    if result.ex is not None:
4311 
      raise result.ex
4312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4313 
 
4386 anupam.sin 4314 
  def getOrderForAwb(self, awb):
4315 
    """
4316 
    Returns the order corresponding to an AWB number
4369 rajveer 4317 
 
4386 anupam.sin 4318 
    Parameters:
4319 
     - awb
4320 
    """
4321 
    self.send_getOrderForAwb(awb)
4322 
    return self.recv_getOrderForAwb()
4323 
 
4324 
  def send_getOrderForAwb(self, awb):
4325 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4326 
    args = getOrderForAwb_args()
4327 
    args.awb = awb
4328 
    args.write(self._oprot)
4329 
    self._oprot.writeMessageEnd()
4330 
    self._oprot.trans.flush()
4331 
 
4332 
  def recv_getOrderForAwb(self, ):
4333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4334 
    if mtype == TMessageType.EXCEPTION:
4335 
      x = TApplicationException()
4336 
      x.read(self._iprot)
4337 
      self._iprot.readMessageEnd()
4338 
      raise x
4339 
    result = getOrderForAwb_result()
4340 
    result.read(self._iprot)
4341 
    self._iprot.readMessageEnd()
4342 
    if result.success is not None:
4343 
      return result.success
4344 
    if result.ex is not None:
4345 
      raise result.ex
4346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4347 
 
4910 phani.kuma 4348 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4349 
    """
4910 phani.kuma 4350 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4351 
 
4506 phani.kuma 4352 
    Parameters:
4353 
     - logistics_provider_id
4910 phani.kuma 4354 
     - order_status_list
4506 phani.kuma 4355 
    """
4910 phani.kuma 4356 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4357 
    return self.recv_getOrdersForProviderForStatus()
4358 
 
4910 phani.kuma 4359 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4360 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4361 
    args = getOrdersForProviderForStatus_args()
4362 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4363 
    args.order_status_list = order_status_list
4506 phani.kuma 4364 
    args.write(self._oprot)
4365 
    self._oprot.writeMessageEnd()
4366 
    self._oprot.trans.flush()
4367 
 
4368 
  def recv_getOrdersForProviderForStatus(self, ):
4369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4370 
    if mtype == TMessageType.EXCEPTION:
4371 
      x = TApplicationException()
4372 
      x.read(self._iprot)
4373 
      self._iprot.readMessageEnd()
4374 
      raise x
4375 
    result = getOrdersForProviderForStatus_result()
4376 
    result.read(self._iprot)
4377 
    self._iprot.readMessageEnd()
4378 
    if result.success is not None:
4379 
      return result.success
4380 
    if result.ex is not None:
4381 
      raise result.ex
4382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4383 
 
4600 varun.gupt 4384 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4385 
    """
4386 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4387 
 
4600 varun.gupt 4388 
    Parameters:
4389 
     - vendorId
4390 
     - billingDateFrom
4391 
     - billingDateTo
4392 
    """
4393 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4394 
    return self.recv_getBilledOrdersForVendor()
4395 
 
4396 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4397 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4398 
    args = getBilledOrdersForVendor_args()
4399 
    args.vendorId = vendorId
4400 
    args.billingDateFrom = billingDateFrom
4401 
    args.billingDateTo = billingDateTo
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_getBilledOrdersForVendor(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = getBilledOrdersForVendor_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    if result.success is not None:
4417 
      return result.success
4418 
    if result.ex is not None:
4419 
      raise result.ex
4420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4421 
 
4607 rajveer 4422 
  def getSlippedSippingDateOrders(self, ):
4423 
    self.send_getSlippedSippingDateOrders()
4424 
    return self.recv_getSlippedSippingDateOrders()
4425 
 
4426 
  def send_getSlippedSippingDateOrders(self, ):
4427 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4428 
    args = getSlippedSippingDateOrders_args()
4429 
    args.write(self._oprot)
4430 
    self._oprot.writeMessageEnd()
4431 
    self._oprot.trans.flush()
4432 
 
4433 
  def recv_getSlippedSippingDateOrders(self, ):
4434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4435 
    if mtype == TMessageType.EXCEPTION:
4436 
      x = TApplicationException()
4437 
      x.read(self._iprot)
4438 
      self._iprot.readMessageEnd()
4439 
      raise x
4440 
    result = getSlippedSippingDateOrders_result()
4441 
    result.read(self._iprot)
4442 
    self._iprot.readMessageEnd()
4443 
    if result.success is not None:
4444 
      return result.success
4445 
    if result.ex is not None:
4446 
      raise result.ex
4447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4448 
 
4709 rajveer 4449 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4450 
    """
4451 
    Parameters:
4452 
     - cancelDateFrom
4453 
     - cancelDateTo
4454 
    """
4455 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4456 
    return self.recv_getCancelledOrders()
4457 
 
4458 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4459 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4460 
    args = getCancelledOrders_args()
4461 
    args.cancelDateFrom = cancelDateFrom
4462 
    args.cancelDateTo = cancelDateTo
4463 
    args.write(self._oprot)
4464 
    self._oprot.writeMessageEnd()
4465 
    self._oprot.trans.flush()
4466 
 
4467 
  def recv_getCancelledOrders(self, ):
4468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4469 
    if mtype == TMessageType.EXCEPTION:
4470 
      x = TApplicationException()
4471 
      x.read(self._iprot)
4472 
      self._iprot.readMessageEnd()
4473 
      raise x
4474 
    result = getCancelledOrders_result()
4475 
    result.read(self._iprot)
4476 
    self._iprot.readMessageEnd()
4477 
    if result.success is not None:
4478 
      return result.success
4479 
    if result.ex is not None:
4480 
      raise result.ex
4481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4482 
 
4600 varun.gupt 4483 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4484 
    """
4485 
    Parameters:
4486 
     - mapAWBAndAmount
4487 
    """
4488 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4489 
    self.recv_saveBluedartSettlements()
4490 
 
4491 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4492 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4493 
    args = saveBluedartSettlements_args()
4494 
    args.mapAWBAndAmount = mapAWBAndAmount
4495 
    args.write(self._oprot)
4496 
    self._oprot.writeMessageEnd()
4497 
    self._oprot.trans.flush()
4498 
 
4499 
  def recv_saveBluedartSettlements(self, ):
4500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4501 
    if mtype == TMessageType.EXCEPTION:
4502 
      x = TApplicationException()
4503 
      x.read(self._iprot)
4504 
      self._iprot.readMessageEnd()
4505 
      raise x
4506 
    result = saveBluedartSettlements_result()
4507 
    result.read(self._iprot)
4508 
    self._iprot.readMessageEnd()
4509 
    if result.ex is not None:
4510 
      raise result.ex
4511 
    return
4512 
 
4905 varun.gupt 4513 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4514 
    """
4515 
    Parameters:
4516 
     - settlementDate
4517 
     - paymentGatewayId
4905 varun.gupt 4518 
     - referenceId
4600 varun.gupt 4519 
     - serviceTax
4520 
     - otherCharges
4521 
     - netCollection
4522 
    """
4905 varun.gupt 4523 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4524 
    self.recv_savePaymentSettlements()
4525 
 
4905 varun.gupt 4526 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4527 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4528 
    args = savePaymentSettlements_args()
4529 
    args.settlementDate = settlementDate
4530 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4531 
    args.referenceId = referenceId
4600 varun.gupt 4532 
    args.serviceTax = serviceTax
4533 
    args.otherCharges = otherCharges
4534 
    args.netCollection = netCollection
4535 
    args.write(self._oprot)
4536 
    self._oprot.writeMessageEnd()
4537 
    self._oprot.trans.flush()
4538 
 
4539 
  def recv_savePaymentSettlements(self, ):
4540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4541 
    if mtype == TMessageType.EXCEPTION:
4542 
      x = TApplicationException()
4543 
      x.read(self._iprot)
4544 
      self._iprot.readMessageEnd()
4545 
      raise x
4546 
    result = savePaymentSettlements_result()
4547 
    result.read(self._iprot)
4548 
    self._iprot.readMessageEnd()
4549 
    if result.ex is not None:
4550 
      raise result.ex
4551 
    return
4552 
 
4553 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4554 
    """
4555 
    Parameters:
4556 
     - settlementId
4557 
     - settlementDate
4558 
     - transactionDateFrom
4559 
     - transactionDateTo
4560 
     - amount
4561 
    """
4562 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4563 
    self.recv_saveEBSSettlementSummary()
4564 
 
4565 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4566 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4567 
    args = saveEBSSettlementSummary_args()
4568 
    args.settlementId = settlementId
4569 
    args.settlementDate = settlementDate
4570 
    args.transactionDateFrom = transactionDateFrom
4571 
    args.transactionDateTo = transactionDateTo
4572 
    args.amount = amount
4573 
    args.write(self._oprot)
4574 
    self._oprot.writeMessageEnd()
4575 
    self._oprot.trans.flush()
4576 
 
4577 
  def recv_saveEBSSettlementSummary(self, ):
4578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4579 
    if mtype == TMessageType.EXCEPTION:
4580 
      x = TApplicationException()
4581 
      x.read(self._iprot)
4582 
      self._iprot.readMessageEnd()
4583 
      raise x
4584 
    result = saveEBSSettlementSummary_result()
4585 
    result.read(self._iprot)
4586 
    self._iprot.readMessageEnd()
4587 
    if result.ex is not None:
4588 
      raise result.ex
4589 
    return
4590 
 
4591 
  def getSettlementForPaymentId(self, paymentId):
4592 
    """
4593 
    Parameters:
4594 
     - paymentId
4595 
    """
4596 
    self.send_getSettlementForPaymentId(paymentId)
4597 
    return self.recv_getSettlementForPaymentId()
4598 
 
4599 
  def send_getSettlementForPaymentId(self, paymentId):
4600 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4601 
    args = getSettlementForPaymentId_args()
4602 
    args.paymentId = paymentId
4603 
    args.write(self._oprot)
4604 
    self._oprot.writeMessageEnd()
4605 
    self._oprot.trans.flush()
4606 
 
4607 
  def recv_getSettlementForPaymentId(self, ):
4608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4609 
    if mtype == TMessageType.EXCEPTION:
4610 
      x = TApplicationException()
4611 
      x.read(self._iprot)
4612 
      self._iprot.readMessageEnd()
4613 
      raise x
4614 
    result = getSettlementForPaymentId_result()
4615 
    result.read(self._iprot)
4616 
    self._iprot.readMessageEnd()
4617 
    if result.success is not None:
4618 
      return result.success
4619 
    if result.ex is not None:
4620 
      raise result.ex
4621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4622 
 
4623 
  def getEBSSettlementSummaries(self, ):
4624 
    self.send_getEBSSettlementSummaries()
4625 
    return self.recv_getEBSSettlementSummaries()
4626 
 
4627 
  def send_getEBSSettlementSummaries(self, ):
4628 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4629 
    args = getEBSSettlementSummaries_args()
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_getEBSSettlementSummaries(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = getEBSSettlementSummaries_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.success is not None:
4645 
      return result.success
4646 
    if result.ex is not None:
4647 
      raise result.ex
4648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4649 
 
4650 
  def markEBSSettlementUploaded(self, settlementId):
4651 
    """
4652 
    Parameters:
4653 
     - settlementId
4654 
    """
4655 
    self.send_markEBSSettlementUploaded(settlementId)
4656 
    self.recv_markEBSSettlementUploaded()
4657 
 
4658 
  def send_markEBSSettlementUploaded(self, settlementId):
4659 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4660 
    args = markEBSSettlementUploaded_args()
4661 
    args.settlementId = settlementId
4662 
    args.write(self._oprot)
4663 
    self._oprot.writeMessageEnd()
4664 
    self._oprot.trans.flush()
4665 
 
4666 
  def recv_markEBSSettlementUploaded(self, ):
4667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4668 
    if mtype == TMessageType.EXCEPTION:
4669 
      x = TApplicationException()
4670 
      x.read(self._iprot)
4671 
      self._iprot.readMessageEnd()
4672 
      raise x
4673 
    result = markEBSSettlementUploaded_result()
4674 
    result.read(self._iprot)
4675 
    self._iprot.readMessageEnd()
4676 
    if result.ex is not None:
4677 
      raise result.ex
4678 
    return
4679 
 
4680 
  def getEBSSettlementDate(self, settlementId):
4681 
    """
4682 
    Parameters:
4683 
     - settlementId
4684 
    """
4685 
    self.send_getEBSSettlementDate(settlementId)
4686 
    return self.recv_getEBSSettlementDate()
4687 
 
4688 
  def send_getEBSSettlementDate(self, settlementId):
4689 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4690 
    args = getEBSSettlementDate_args()
4691 
    args.settlementId = settlementId
4692 
    args.write(self._oprot)
4693 
    self._oprot.writeMessageEnd()
4694 
    self._oprot.trans.flush()
4695 
 
4696 
  def recv_getEBSSettlementDate(self, ):
4697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4698 
    if mtype == TMessageType.EXCEPTION:
4699 
      x = TApplicationException()
4700 
      x.read(self._iprot)
4701 
      self._iprot.readMessageEnd()
4702 
      raise x
4703 
    result = getEBSSettlementDate_result()
4704 
    result.read(self._iprot)
4705 
    self._iprot.readMessageEnd()
4706 
    if result.success is not None:
4707 
      return result.success
4708 
    if result.ex is not None:
4709 
      raise result.ex
4710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4711 
 
4715 varun.gupt 4712 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4713 
    """
4714 
    Parameters:
4715 
     - settlementDateFrom
4716 
     - settlementDateTo
4717 
     - isRefund
4718 
    """
4719 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4720 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4721 
 
4715 varun.gupt 4722 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4723 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4724 
    args = getSettlementsByDate_args()
4725 
    args.settlementDateFrom = settlementDateFrom
4726 
    args.settlementDateTo = settlementDateTo
4727 
    args.isRefund = isRefund
4728 
    args.write(self._oprot)
4729 
    self._oprot.writeMessageEnd()
4730 
    self._oprot.trans.flush()
4731 
 
4732 
  def recv_getSettlementsByDate(self, ):
4733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4734 
    if mtype == TMessageType.EXCEPTION:
4735 
      x = TApplicationException()
4736 
      x.read(self._iprot)
4737 
      self._iprot.readMessageEnd()
4738 
      raise x
4739 
    result = getSettlementsByDate_result()
4740 
    result.read(self._iprot)
4741 
    self._iprot.readMessageEnd()
4742 
    if result.success is not None:
4743 
      return result.success
4744 
    if result.ex is not None:
4745 
      raise result.ex
4746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4747 
 
4748 
  def getReshippedOrderIds(self, orderIds):
4749 
    """
4750 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4751 
 
4752 
    Parameters:
4753 
     - orderIds
4754 
    """
4755 
    self.send_getReshippedOrderIds(orderIds)
4756 
    return self.recv_getReshippedOrderIds()
4757 
 
4758 
  def send_getReshippedOrderIds(self, orderIds):
4759 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4760 
    args = getReshippedOrderIds_args()
4761 
    args.orderIds = orderIds
4762 
    args.write(self._oprot)
4763 
    self._oprot.writeMessageEnd()
4764 
    self._oprot.trans.flush()
4765 
 
4766 
  def recv_getReshippedOrderIds(self, ):
4767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4768 
    if mtype == TMessageType.EXCEPTION:
4769 
      x = TApplicationException()
4770 
      x.read(self._iprot)
4771 
      self._iprot.readMessageEnd()
4772 
      raise x
4773 
    result = getReshippedOrderIds_result()
4774 
    result.read(self._iprot)
4775 
    self._iprot.readMessageEnd()
4776 
    if result.success is not None:
4777 
      return result.success
4778 
    if result.ex is not None:
4779 
      raise result.ex
4780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4781 
 
4757 mandeep.dh 4782 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4783 
    """
4784 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4785 
    the quantities for which the PO is raised.
4715 varun.gupt 4786 
 
4757 mandeep.dh 4787 
    Parameters:
4788 
     - itemIdQuantityMap
4789 
     - purchaseOrderId
4790 
     - warehouseId
4791 
    """
4792 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4793 
    self.recv_updateOrdersAsPORaised()
4794 
 
4795 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4796 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4797 
    args = updateOrdersAsPORaised_args()
4798 
    args.itemIdQuantityMap = itemIdQuantityMap
4799 
    args.purchaseOrderId = purchaseOrderId
4800 
    args.warehouseId = warehouseId
4801 
    args.write(self._oprot)
4802 
    self._oprot.writeMessageEnd()
4803 
    self._oprot.trans.flush()
4804 
 
4805 
  def recv_updateOrdersAsPORaised(self, ):
4806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4807 
    if mtype == TMessageType.EXCEPTION:
4808 
      x = TApplicationException()
4809 
      x.read(self._iprot)
4810 
      self._iprot.readMessageEnd()
4811 
      raise x
4812 
    result = updateOrdersAsPORaised_result()
4813 
    result.read(self._iprot)
4814 
    self._iprot.readMessageEnd()
4815 
    if result.ex is not None:
4816 
      raise result.ex
4817 
    return
4818 
 
4875 varun.gupt 4819 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4820 
    """
4821 
    Parameters:
4822 
     - vendorId
4823 
    """
4824 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4825 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4826 
 
4875 varun.gupt 4827 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4828 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4829 
    args = getOrdersWhereVendorNotPaid_args()
4830 
    args.vendorId = vendorId
4831 
    args.write(self._oprot)
4832 
    self._oprot.writeMessageEnd()
4833 
    self._oprot.trans.flush()
4834 
 
4835 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4837 
    if mtype == TMessageType.EXCEPTION:
4838 
      x = TApplicationException()
4839 
      x.read(self._iprot)
4840 
      self._iprot.readMessageEnd()
4841 
      raise x
4842 
    result = getOrdersWhereVendorNotPaid_result()
4843 
    result.read(self._iprot)
4844 
    self._iprot.readMessageEnd()
4845 
    if result.success is not None:
4846 
      return result.success
4847 
    if result.ex is not None:
4848 
      raise result.ex
4849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4850 
 
4851 
 
3376 rajveer 4852 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4853 
  def __init__(self, handler):
3376 rajveer 4854 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4855 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4856 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4857 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4858 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4859 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4860 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4861 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4862 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4863 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4864 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4865 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4866 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4867 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4868 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4869 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4870 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4871 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4872 
    self._processMap["createOrder"] = Processor.process_createOrder
4873 
    self._processMap["getOrder"] = Processor.process_getOrder
4874 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 4875 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 4876 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4877 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4878 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4879 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4880 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4881 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4882 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4883 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4884 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4885 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4886 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4887 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4888 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4889 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 4890 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4891 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 4892 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 4893 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 4894 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
4895 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 4896 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 4897 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
4898 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
4899 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
4900 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
4901 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 4902 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4903 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4904 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4905 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4906 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4907 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4908 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4909 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4910 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4911 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4912 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 4913 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 4914 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 4915 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 4916 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4917 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4918 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4919 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4920 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4921 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4922 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4923 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4924 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4925 
    self._processMap["changeItem"] = Processor.process_changeItem
4926 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4927 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4928 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4929 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4930 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4931 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4932 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4933 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4934 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4935 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4936 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4937 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4938 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4939 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4940 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4941 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4942 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4943 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4944 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4945 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4946 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4947 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4948 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4949 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4950 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4951 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4952 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4953 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4954 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4955 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4956 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4957 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4958 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4959 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 4960 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
94 ashish 4961 
 
4962 
  def process(self, iprot, oprot):
4963 
    (name, type, seqid) = iprot.readMessageBegin()
4964 
    if name not in self._processMap:
4965 
      iprot.skip(TType.STRUCT)
4966 
      iprot.readMessageEnd()
4967 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4968 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4969 
      x.write(oprot)
4970 
      oprot.writeMessageEnd()
4971 
      oprot.trans.flush()
4972 
      return
4973 
    else:
4974 
      self._processMap[name](self, seqid, iprot, oprot)
4975 
    return True
4976 
 
4977 
  def process_createTransaction(self, seqid, iprot, oprot):
4978 
    args = createTransaction_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = createTransaction_result()
4982 
    try:
132 ashish 4983 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4984 
    except TransactionServiceException, ex:
4985 
      result.ex = ex
4986 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
4990 
 
4991 
  def process_getTransaction(self, seqid, iprot, oprot):
4992 
    args = getTransaction_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = getTransaction_result()
4996 
    try:
4997 
      result.success = self._handler.getTransaction(args.id)
4998 
    except TransactionServiceException, ex:
4999 
      result.ex = ex
5000 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5001 
    result.write(oprot)
5002 
    oprot.writeMessageEnd()
5003 
    oprot.trans.flush()
5004 
 
5005 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5006 
    args = getTransactionsForCustomer_args()
5007 
    args.read(iprot)
5008 
    iprot.readMessageEnd()
5009 
    result = getTransactionsForCustomer_result()
5010 
    try:
5011 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5012 
    except TransactionServiceException, ex:
5013 
      result.ex = ex
5014 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
5018 
 
132 ashish 5019 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5020 
    args = getTransactionsForShoppingCartId_args()
5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
5023 
    result = getTransactionsForShoppingCartId_result()
5024 
    try:
5025 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5026 
    except TransactionServiceException, ex:
5027 
      result.ex = ex
5028 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
5032 
 
94 ashish 5033 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5034 
    args = getTransactionStatus_args()
5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
5037 
    result = getTransactionStatus_result()
5038 
    try:
5039 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5040 
    except TransactionServiceException, ex:
5041 
      result.ex = ex
5042 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5043 
    result.write(oprot)
5044 
    oprot.writeMessageEnd()
5045 
    oprot.trans.flush()
5046 
 
5047 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5048 
    args = changeTransactionStatus_args()
5049 
    args.read(iprot)
5050 
    iprot.readMessageEnd()
5051 
    result = changeTransactionStatus_result()
5052 
    try:
5053 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5054 
    except TransactionServiceException, ex:
5055 
      result.ex = ex
5056 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5057 
    result.write(oprot)
5058 
    oprot.writeMessageEnd()
5059 
    oprot.trans.flush()
5060 
 
1398 varun.gupt 5061 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5062 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5063 
    args.read(iprot)
5064 
    iprot.readMessageEnd()
1398 varun.gupt 5065 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5066 
    try:
1398 varun.gupt 5067 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5068 
    except TransactionServiceException, ex:
5069 
      result.ex = ex
1398 varun.gupt 5070 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
483 rajveer 5075 
  def process_getAllOrders(self, seqid, iprot, oprot):
5076 
    args = getAllOrders_args()
94 ashish 5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
483 rajveer 5079 
    result = getAllOrders_result()
94 ashish 5080 
    try:
4801 anupam.sin 5081 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5082 
    except TransactionServiceException, ex:
5083 
      result.ex = ex
483 rajveer 5084 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
4133 chandransh 5089 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5090 
    args = getOrdersInBatch_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = getOrdersInBatch_result()
5094 
    try:
5095 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5096 
    except TransactionServiceException, ex:
5097 
      result.ex = ex
5098 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5099 
    result.write(oprot)
5100 
    oprot.writeMessageEnd()
5101 
    oprot.trans.flush()
5102 
 
5103 
  def process_getOrderCount(self, seqid, iprot, oprot):
5104 
    args = getOrderCount_args()
5105 
    args.read(iprot)
5106 
    iprot.readMessageEnd()
5107 
    result = getOrderCount_result()
5108 
    try:
5109 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5110 
    except TransactionServiceException, ex:
5111 
      result.ex = ex
5112 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
5116 
 
999 varun.gupt 5117 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5118 
    args = getOrdersByBillingDate_args()
5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
5121 
    result = getOrdersByBillingDate_result()
5122 
    try:
5123 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5124 
    except TransactionServiceException, ex:
5125 
      result.ex = ex
5126 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
5130 
 
3427 chandransh 5131 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5132 
    args = getOrdersByShippingDate_args()
5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
5135 
    result = getOrdersByShippingDate_result()
5136 
    try:
3451 chandransh 5137 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5138 
    except TransactionServiceException, ex:
5139 
      result.ex = ex
5140 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5141 
    result.write(oprot)
5142 
    oprot.writeMessageEnd()
5143 
    oprot.trans.flush()
5144 
 
1382 varun.gupt 5145 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5146 
    args = getReturnableOrdersForCustomer_args()
5147 
    args.read(iprot)
5148 
    iprot.readMessageEnd()
5149 
    result = getReturnableOrdersForCustomer_result()
5150 
    try:
5151 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5152 
    except TransactionServiceException, ex:
5153 
      result.ex = ex
5154 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5155 
    result.write(oprot)
5156 
    oprot.writeMessageEnd()
5157 
    oprot.trans.flush()
5158 
 
5159 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5160 
    args = getCancellableOrdersForCustomer_args()
5161 
    args.read(iprot)
5162 
    iprot.readMessageEnd()
5163 
    result = getCancellableOrdersForCustomer_result()
5164 
    try:
5165 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5166 
    except TransactionServiceException, ex:
5167 
      result.ex = ex
5168 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5169 
    result.write(oprot)
5170 
    oprot.writeMessageEnd()
5171 
    oprot.trans.flush()
5172 
 
483 rajveer 5173 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5174 
    args = changeOrderStatus_args()
94 ashish 5175 
    args.read(iprot)
5176 
    iprot.readMessageEnd()
483 rajveer 5177 
    result = changeOrderStatus_result()
94 ashish 5178 
    try:
483 rajveer 5179 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5180 
    except TransactionServiceException, ex:
5181 
      result.ex = ex
483 rajveer 5182 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5183 
    result.write(oprot)
5184 
    oprot.writeMessageEnd()
5185 
    oprot.trans.flush()
5186 
 
483 rajveer 5187 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5188 
    args = getOrdersForTransaction_args()
94 ashish 5189 
    args.read(iprot)
5190 
    iprot.readMessageEnd()
483 rajveer 5191 
    result = getOrdersForTransaction_result()
94 ashish 5192 
    try:
1528 ankur.sing 5193 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5194 
    except TransactionServiceException, ex:
5195 
      result.ex = ex
483 rajveer 5196 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5197 
    result.write(oprot)
5198 
    oprot.writeMessageEnd()
5199 
    oprot.trans.flush()
5200 
 
483 rajveer 5201 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5202 
    args = getOrdersForCustomer_args()
94 ashish 5203 
    args.read(iprot)
5204 
    iprot.readMessageEnd()
483 rajveer 5205 
    result = getOrdersForCustomer_result()
94 ashish 5206 
    try:
3014 chandransh 5207 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5208 
    except TransactionServiceException, ex:
5209 
      result.ex = ex
483 rajveer 5210 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5211 
    result.write(oprot)
5212 
    oprot.writeMessageEnd()
5213 
    oprot.trans.flush()
5214 
 
483 rajveer 5215 
  def process_createOrder(self, seqid, iprot, oprot):
5216 
    args = createOrder_args()
94 ashish 5217 
    args.read(iprot)
5218 
    iprot.readMessageEnd()
483 rajveer 5219 
    result = createOrder_result()
94 ashish 5220 
    try:
483 rajveer 5221 
      result.success = self._handler.createOrder(args.order)
94 ashish 5222 
    except TransactionServiceException, ex:
5223 
      result.ex = ex
483 rajveer 5224 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5225 
    result.write(oprot)
5226 
    oprot.writeMessageEnd()
5227 
    oprot.trans.flush()
5228 
 
483 rajveer 5229 
  def process_getOrder(self, seqid, iprot, oprot):
5230 
    args = getOrder_args()
94 ashish 5231 
    args.read(iprot)
5232 
    iprot.readMessageEnd()
483 rajveer 5233 
    result = getOrder_result()
94 ashish 5234 
    try:
483 rajveer 5235 
      result.success = self._handler.getOrder(args.id)
94 ashish 5236 
    except TransactionServiceException, ex:
5237 
      result.ex = ex
483 rajveer 5238 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5239 
    result.write(oprot)
5240 
    oprot.writeMessageEnd()
5241 
    oprot.trans.flush()
5242 
 
483 rajveer 5243 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5244 
    args = getLineItemsForOrder_args()
94 ashish 5245 
    args.read(iprot)
5246 
    iprot.readMessageEnd()
483 rajveer 5247 
    result = getLineItemsForOrder_result()
94 ashish 5248 
    try:
483 rajveer 5249 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5250 
    except TransactionServiceException, ex:
5251 
      result.ex = ex
483 rajveer 5252 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5253 
    result.write(oprot)
5254 
    oprot.writeMessageEnd()
5255 
    oprot.trans.flush()
5256 
 
4999 phani.kuma 5257 
  def process_getOrderList(self, seqid, iprot, oprot):
5258 
    args = getOrderList_args()
5259 
    args.read(iprot)
5260 
    iprot.readMessageEnd()
5261 
    result = getOrderList_result()
5262 
    result.success = self._handler.getOrderList(args.order_ids)
5263 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5264 
    result.write(oprot)
5265 
    oprot.writeMessageEnd()
5266 
    oprot.trans.flush()
5267 
 
1528 ankur.sing 5268 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5269 
    args = getOrderForCustomer_args()
5270 
    args.read(iprot)
5271 
    iprot.readMessageEnd()
5272 
    result = getOrderForCustomer_result()
5273 
    try:
5274 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5275 
    except TransactionServiceException, ex:
5276 
      result.ex = ex
5277 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5278 
    result.write(oprot)
5279 
    oprot.writeMessageEnd()
5280 
    oprot.trans.flush()
5281 
 
3064 chandransh 5282 
  def process_getAlerts(self, seqid, iprot, oprot):
5283 
    args = getAlerts_args()
5284 
    args.read(iprot)
5285 
    iprot.readMessageEnd()
5286 
    result = getAlerts_result()
4444 rajveer 5287 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5288 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5289 
    result.write(oprot)
5290 
    oprot.writeMessageEnd()
5291 
    oprot.trans.flush()
5292 
 
4394 rajveer 5293 
  def process_addAlert(self, seqid, iprot, oprot):
5294 
    args = addAlert_args()
3064 chandransh 5295 
    args.read(iprot)
5296 
    iprot.readMessageEnd()
4394 rajveer 5297 
    result = addAlert_result()
4444 rajveer 5298 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5299 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5300 
    result.write(oprot)
5301 
    oprot.writeMessageEnd()
5302 
    oprot.trans.flush()
5303 
 
4444 rajveer 5304 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5305 
    args = markAlertsAsSeen_args()
5306 
    args.read(iprot)
5307 
    iprot.readMessageEnd()
5308 
    result = markAlertsAsSeen_result()
5309 
    self._handler.markAlertsAsSeen(args.warehouseId)
5310 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5311 
    result.write(oprot)
5312 
    oprot.writeMessageEnd()
5313 
    oprot.trans.flush()
5314 
 
3064 chandransh 5315 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5316 
    args = getValidOrderCount_args()
5317 
    args.read(iprot)
5318 
    iprot.readMessageEnd()
5319 
    result = getValidOrderCount_result()
5320 
    result.success = self._handler.getValidOrderCount()
5321 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
5325 
 
5326 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5327 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
5330 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5331 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5332 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
5336 
 
5337 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5338 
    args = getValidOrdersAmountRange_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = getValidOrdersAmountRange_result()
5342 
    result.success = self._handler.getValidOrdersAmountRange()
5343 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5344 
    result.write(oprot)
5345 
    oprot.writeMessageEnd()
5346 
    oprot.trans.flush()
5347 
 
5348 
  def process_getValidOrders(self, seqid, iprot, oprot):
5349 
    args = getValidOrders_args()
5350 
    args.read(iprot)
5351 
    iprot.readMessageEnd()
5352 
    result = getValidOrders_result()
5353 
    result.success = self._handler.getValidOrders(args.limit)
5354 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
5358 
 
1220 chandransh 5359 
  def process_batchOrders(self, seqid, iprot, oprot):
5360 
    args = batchOrders_args()
5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
5363 
    result = batchOrders_result()
5364 
    try:
5365 
      result.success = self._handler.batchOrders(args.warehouseId)
5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
5368 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
1208 chandransh 5373 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5374 
    args = markOrderAsOutOfStock_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = markOrderAsOutOfStock_result()
5378 
    try:
5379 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
5382 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
3064 chandransh 5387 
  def process_verifyOrder(self, seqid, iprot, oprot):
5388 
    args = verifyOrder_args()
759 chandransh 5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
3064 chandransh 5391 
    result = verifyOrder_result()
759 chandransh 5392 
    try:
3064 chandransh 5393 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5394 
    except TransactionServiceException, ex:
5395 
      result.ex = ex
3064 chandransh 5396 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
5400 
 
3064 chandransh 5401 
  def process_acceptOrder(self, seqid, iprot, oprot):
5402 
    args = acceptOrder_args()
1113 chandransh 5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
3064 chandransh 5405 
    result = acceptOrder_result()
1113 chandransh 5406 
    try:
3064 chandransh 5407 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5408 
    except TransactionServiceException, ex:
5409 
      result.ex = ex
3064 chandransh 5410 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
5414 
 
3064 chandransh 5415 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5416 
    args = addBillingDetails_args()
1135 chandransh 5417 
    args.read(iprot)
5418 
    iprot.readMessageEnd()
3064 chandransh 5419 
    result = addBillingDetails_result()
1135 chandransh 5420 
    try:
4763 rajveer 5421 
      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 5422 
    except TransactionServiceException, ex:
5423 
      result.ex = ex
3064 chandransh 5424 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5425 
    result.write(oprot)
5426 
    oprot.writeMessageEnd()
5427 
    oprot.trans.flush()
5428 
 
4579 rajveer 5429 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5430 
    args = addInvoiceNumber_args()
5431 
    args.read(iprot)
5432 
    iprot.readMessageEnd()
5433 
    result = addInvoiceNumber_result()
5434 
    try:
4763 rajveer 5435 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5436 
    except TransactionServiceException, ex:
5437 
      result.ex = ex
5438 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5439 
    result.write(oprot)
5440 
    oprot.writeMessageEnd()
5441 
    oprot.trans.flush()
5442 
 
4410 rajveer 5443 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5444 
    args = markOrdersAsShippedFromWarehouse_args()
5445 
    args.read(iprot)
5446 
    iprot.readMessageEnd()
5447 
    result = markOrdersAsShippedFromWarehouse_result()
5448 
    try:
4789 rajveer 5449 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5450 
    except TransactionServiceException, ex:
5451 
      result.ex = ex
5452 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5453 
    result.write(oprot)
5454 
    oprot.writeMessageEnd()
5455 
    oprot.trans.flush()
5456 
 
3064 chandransh 5457 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5458 
    args = markOrdersAsPickedUp_args()
304 ashish 5459 
    args.read(iprot)
5460 
    iprot.readMessageEnd()
3064 chandransh 5461 
    result = markOrdersAsPickedUp_result()
5462 
    try:
4910 phani.kuma 5463 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5464 
    except TransactionServiceException, ex:
5465 
      result.ex = ex
5466 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5467 
    result.write(oprot)
5468 
    oprot.writeMessageEnd()
5469 
    oprot.trans.flush()
94 ashish 5470 
 
4910 phani.kuma 5471 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5472 
    args = getOrdersNotPickedUp_args()
5473 
    args.read(iprot)
5474 
    iprot.readMessageEnd()
5475 
    result = getOrdersNotPickedUp_result()
5476 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5477 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
5481 
 
3064 chandransh 5482 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5483 
    args = markOrdersAsDelivered_args()
304 ashish 5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
3064 chandransh 5486 
    result = markOrdersAsDelivered_result()
5487 
    try:
5488 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5489 
    except TransactionServiceException, ex:
5490 
      result.ex = ex
5491 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5492 
    result.write(oprot)
5493 
    oprot.writeMessageEnd()
5494 
    oprot.trans.flush()
5495 
 
4910 phani.kuma 5496 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5497 
    args = markAsRTOrders_args()
1596 ankur.sing 5498 
    args.read(iprot)
5499 
    iprot.readMessageEnd()
4910 phani.kuma 5500 
    result = markAsRTOrders_result()
3064 chandransh 5501 
    try:
4910 phani.kuma 5502 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5503 
    except TransactionServiceException, ex:
5504 
      result.ex = ex
4910 phani.kuma 5505 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5506 
    result.write(oprot)
5507 
    oprot.writeMessageEnd()
5508 
    oprot.trans.flush()
304 ashish 5509 
 
4910 phani.kuma 5510 
  def process_getRTOrders(self, seqid, iprot, oprot):
5511 
    args = getRTOrders_args()
5512 
    args.read(iprot)
5513 
    iprot.readMessageEnd()
5514 
    result = getRTOrders_result()
5515 
    result.success = self._handler.getRTOrders(args.providerId)
5516 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5517 
    result.write(oprot)
5518 
    oprot.writeMessageEnd()
5519 
    oprot.trans.flush()
5520 
 
3064 chandransh 5521 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5522 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5523 
    args.read(iprot)
5524 
    iprot.readMessageEnd()
3064 chandransh 5525 
    result = updateNonDeliveryReason_result()
5526 
    try:
4910 phani.kuma 5527 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5528 
    except TransactionServiceException, ex:
5529 
      result.ex = ex
5530 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5531 
    result.write(oprot)
5532 
    oprot.writeMessageEnd()
5533 
    oprot.trans.flush()
1596 ankur.sing 5534 
 
4910 phani.kuma 5535 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5536 
    args = getNonDeliveredOrdersbyCourier_args()
5537 
    args.read(iprot)
5538 
    iprot.readMessageEnd()
5539 
    result = getNonDeliveredOrdersbyCourier_result()
5540 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5541 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5542 
    result.write(oprot)
5543 
    oprot.writeMessageEnd()
5544 
    oprot.trans.flush()
5545 
 
5546 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5547 
    args = markOrdersAsLocalConnected_args()
5548 
    args.read(iprot)
5549 
    iprot.readMessageEnd()
5550 
    result = markOrdersAsLocalConnected_result()
5551 
    try:
5552 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5553 
    except TransactionServiceException, ex:
5554 
      result.ex = ex
5555 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5556 
    result.write(oprot)
5557 
    oprot.writeMessageEnd()
5558 
    oprot.trans.flush()
5559 
 
5560 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5561 
    args = getOrdersNotLocalConnected_args()
5562 
    args.read(iprot)
5563 
    iprot.readMessageEnd()
5564 
    result = getOrdersNotLocalConnected_result()
5565 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5566 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
5571 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5572 
    args = markOrdersAsDestinationCityReached_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = markOrdersAsDestinationCityReached_result()
5576 
    try:
5577 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5578 
    except TransactionServiceException, ex:
5579 
      result.ex = ex
5580 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
5585 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5586 
    args = markOrdersAsFirstDeliveryAttempted_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = markOrdersAsFirstDeliveryAttempted_result()
5590 
    try:
5591 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5592 
    except TransactionServiceException, ex:
5593 
      result.ex = ex
5594 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5595 
    result.write(oprot)
5596 
    oprot.writeMessageEnd()
5597 
    oprot.trans.flush()
5598 
 
3064 chandransh 5599 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5600 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5601 
    args.read(iprot)
5602 
    iprot.readMessageEnd()
3064 chandransh 5603 
    result = getUndeliveredOrders_result()
5604 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5605 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
5609 
 
4783 phani.kuma 5610 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5611 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
5614 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5615 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5616 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
2536 chandransh 5621 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5622 
    args = toggleDOAFlag_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = toggleDOAFlag_result()
5626 
    try:
5627 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5628 
    except TransactionServiceException, ex:
5629 
      result.ex = ex
5630 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
1886 ankur.sing 5634 
 
4712 rajveer 5635 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5636 
    args = markOrderAsDelivered_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = markOrderAsDelivered_result()
5640 
    try:
5641 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5642 
    except TransactionServiceException, ex:
5643 
      result.ex = ex
5644 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
5648 
 
4454 rajveer 5649 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5650 
    args = markOrderDoaRequestReceived_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = markOrderDoaRequestReceived_result()
5654 
    try:
5655 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5656 
    except TransactionServiceException, ex:
5657 
      result.ex = ex
5658 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
5663 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5664 
    args = markOrderDoaRequestAuthorized_args()
5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
5667 
    result = markOrderDoaRequestAuthorized_result()
5668 
    try:
5669 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5670 
    except TransactionServiceException, ex:
5671 
      result.ex = ex
5672 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
5676 
 
4488 rajveer 5677 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5678 
    args = markOrderReturnRequestReceived_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = markOrderReturnRequestReceived_result()
5682 
    try:
5683 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5684 
    except TransactionServiceException, ex:
5685 
      result.ex = ex
5686 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
5691 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5692 
    args = markOrderReturnRequestAuthorized_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = markOrderReturnRequestAuthorized_result()
5696 
    try:
5697 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5698 
    except TransactionServiceException, ex:
5699 
      result.ex = ex
5700 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
2536 chandransh 5705 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5706 
    args = requestPickupNumber_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = requestPickupNumber_result()
5710 
    try:
4579 rajveer 5711 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5712 
    except TransactionServiceException, ex:
5713 
      result.ex = ex
5714 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
5718 
 
5719 
  def process_authorizePickup(self, seqid, iprot, oprot):
5720 
    args = authorizePickup_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = authorizePickup_result()
5724 
    try:
4602 rajveer 5725 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5726 
    except TransactionServiceException, ex:
5727 
      result.ex = ex
5728 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
2764 chandransh 5733 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5734 
    args = markDoasAsPickedUp_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5738 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5739 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5740 
    result.write(oprot)
5741 
    oprot.writeMessageEnd()
5742 
    oprot.trans.flush()
5743 
 
4910 phani.kuma 5744 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5745 
    args = getDoasNotPickedUp_args()
5746 
    args.read(iprot)
5747 
    iprot.readMessageEnd()
5748 
    result = getDoasNotPickedUp_result()
5749 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5750 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5751 
    result.write(oprot)
5752 
    oprot.writeMessageEnd()
5753 
    oprot.trans.flush()
5754 
 
4741 phani.kuma 5755 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5756 
    args = markReturnOrdersAsPickedUp_args()
5757 
    args.read(iprot)
5758 
    iprot.readMessageEnd()
5759 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5760 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5761 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5762 
    result.write(oprot)
5763 
    oprot.writeMessageEnd()
5764 
    oprot.trans.flush()
5765 
 
4910 phani.kuma 5766 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5767 
    args = getReturnOrdersNotPickedUp_args()
5768 
    args.read(iprot)
5769 
    iprot.readMessageEnd()
5770 
    result = getReturnOrdersNotPickedUp_result()
5771 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5772 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5773 
    result.write(oprot)
5774 
    oprot.writeMessageEnd()
5775 
    oprot.trans.flush()
5776 
 
2616 chandransh 5777 
  def process_receiveReturn(self, seqid, iprot, oprot):
5778 
    args = receiveReturn_args()
2591 chandransh 5779 
    args.read(iprot)
5780 
    iprot.readMessageEnd()
2616 chandransh 5781 
    result = receiveReturn_result()
2591 chandransh 5782 
    try:
4479 rajveer 5783 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5784 
    except TransactionServiceException, ex:
5785 
      result.ex = ex
2616 chandransh 5786 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5787 
    result.write(oprot)
5788 
    oprot.writeMessageEnd()
5789 
    oprot.trans.flush()
2536 chandransh 5790 
 
2591 chandransh 5791 
  def process_validateDoa(self, seqid, iprot, oprot):
5792 
    args = validateDoa_args()
5793 
    args.read(iprot)
5794 
    iprot.readMessageEnd()
5795 
    result = validateDoa_result()
5796 
    try:
5797 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5798 
    except TransactionServiceException, ex:
5799 
      result.ex = ex
5800 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5801 
    result.write(oprot)
5802 
    oprot.writeMessageEnd()
5803 
    oprot.trans.flush()
5804 
 
4495 rajveer 5805 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5806 
    args = validateReturnProduct_args()
5807 
    args.read(iprot)
5808 
    iprot.readMessageEnd()
5809 
    result = validateReturnProduct_result()
5810 
    try:
5811 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5812 
    except TransactionServiceException, ex:
5813 
      result.ex = ex
5814 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5815 
    result.write(oprot)
5816 
    oprot.writeMessageEnd()
5817 
    oprot.trans.flush()
5818 
 
2616 chandransh 5819 
  def process_reshipOrder(self, seqid, iprot, oprot):
5820 
    args = reshipOrder_args()
5821 
    args.read(iprot)
5822 
    iprot.readMessageEnd()
5823 
    result = reshipOrder_result()
5824 
    try:
5825 
      result.success = self._handler.reshipOrder(args.orderId)
5826 
    except TransactionServiceException, ex:
5827 
      result.ex = ex
5828 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5829 
    result.write(oprot)
5830 
    oprot.writeMessageEnd()
5831 
    oprot.trans.flush()
2591 chandransh 5832 
 
2616 chandransh 5833 
  def process_refundOrder(self, seqid, iprot, oprot):
5834 
    args = refundOrder_args()
5835 
    args.read(iprot)
5836 
    iprot.readMessageEnd()
5837 
    result = refundOrder_result()
5838 
    try:
3226 chandransh 5839 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5840 
    except TransactionServiceException, ex:
5841 
      result.ex = ex
5842 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5843 
    result.write(oprot)
5844 
    oprot.writeMessageEnd()
5845 
    oprot.trans.flush()
5846 
 
2690 chandransh 5847 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5848 
    args = getReturnOrders_args()
5849 
    args.read(iprot)
5850 
    iprot.readMessageEnd()
5851 
    result = getReturnOrders_result()
5852 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5853 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5854 
    result.write(oprot)
5855 
    oprot.writeMessageEnd()
5856 
    oprot.trans.flush()
2616 chandransh 5857 
 
2700 chandransh 5858 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5859 
    args = getReturnOrder_args()
5860 
    args.read(iprot)
5861 
    iprot.readMessageEnd()
5862 
    result = getReturnOrder_result()
5863 
    try:
5864 
      result.success = self._handler.getReturnOrder(args.id)
5865 
    except TransactionServiceException, ex:
5866 
      result.ex = ex
5867 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5868 
    result.write(oprot)
5869 
    oprot.writeMessageEnd()
5870 
    oprot.trans.flush()
5871 
 
2690 chandransh 5872 
  def process_processReturn(self, seqid, iprot, oprot):
5873 
    args = processReturn_args()
5874 
    args.read(iprot)
5875 
    iprot.readMessageEnd()
5876 
    result = processReturn_result()
5877 
    try:
5878 
      self._handler.processReturn(args.returnOrderId)
5879 
    except TransactionServiceException, ex:
5880 
      result.ex = ex
5881 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5882 
    result.write(oprot)
5883 
    oprot.writeMessageEnd()
5884 
    oprot.trans.flush()
5885 
 
3451 chandransh 5886 
  def process_updateWeight(self, seqid, iprot, oprot):
5887 
    args = updateWeight_args()
5888 
    args.read(iprot)
5889 
    iprot.readMessageEnd()
5890 
    result = updateWeight_result()
5891 
    try:
5892 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5893 
    except TransactionServiceException, ex:
5894 
      result.ex = ex
5895 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5896 
    result.write(oprot)
5897 
    oprot.writeMessageEnd()
5898 
    oprot.trans.flush()
2819 chandransh 5899 
 
3469 chandransh 5900 
  def process_changeItem(self, seqid, iprot, oprot):
5901 
    args = changeItem_args()
5902 
    args.read(iprot)
5903 
    iprot.readMessageEnd()
5904 
    result = changeItem_result()
5905 
    try:
5906 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5907 
    except TransactionServiceException, ex:
5908 
      result.ex = ex
5909 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5910 
    result.write(oprot)
5911 
    oprot.writeMessageEnd()
5912 
    oprot.trans.flush()
3451 chandransh 5913 
 
3469 chandransh 5914 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5915 
    args = shiftToWarehouse_args()
5916 
    args.read(iprot)
5917 
    iprot.readMessageEnd()
5918 
    result = shiftToWarehouse_result()
5919 
    try:
5920 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5921 
    except TransactionServiceException, ex:
5922 
      result.ex = ex
5923 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
5927 
 
3553 chandransh 5928 
  def process_addDelayReason(self, seqid, iprot, oprot):
5929 
    args = addDelayReason_args()
5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
5932 
    result = addDelayReason_result()
5933 
    try:
4647 rajveer 5934 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5935 
    except TransactionServiceException, ex:
5936 
      result.ex = ex
5937 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5938 
    result.write(oprot)
5939 
    oprot.writeMessageEnd()
5940 
    oprot.trans.flush()
3469 chandransh 5941 
 
3956 chandransh 5942 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5943 
    args = reconcileCodCollection_args()
5944 
    args.read(iprot)
5945 
    iprot.readMessageEnd()
5946 
    result = reconcileCodCollection_result()
5947 
    try:
5948 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5949 
    except TransactionServiceException, ex:
5950 
      result.ex = ex
5951 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5952 
    result.write(oprot)
5953 
    oprot.writeMessageEnd()
5954 
    oprot.trans.flush()
3553 chandransh 5955 
 
4008 mandeep.dh 5956 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5957 
    args = getTransactionsRequiringExtraProcessing_args()
5958 
    args.read(iprot)
5959 
    iprot.readMessageEnd()
5960 
    result = getTransactionsRequiringExtraProcessing_result()
5961 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5962 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5963 
    result.write(oprot)
5964 
    oprot.writeMessageEnd()
5965 
    oprot.trans.flush()
3956 chandransh 5966 
 
4008 mandeep.dh 5967 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5968 
    args = markTransactionAsProcessed_args()
5969 
    args.read(iprot)
5970 
    iprot.readMessageEnd()
5971 
    result = markTransactionAsProcessed_result()
5972 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5973 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5974 
    result.write(oprot)
5975 
    oprot.writeMessageEnd()
5976 
    oprot.trans.flush()
5977 
 
4018 chandransh 5978 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5979 
    args = getItemWiseRiskyOrdersCount_args()
5980 
    args.read(iprot)
5981 
    iprot.readMessageEnd()
5982 
    result = getItemWiseRiskyOrdersCount_result()
5983 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5984 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5985 
    result.write(oprot)
5986 
    oprot.writeMessageEnd()
5987 
    oprot.trans.flush()
4008 mandeep.dh 5988 
 
4295 varun.gupt 5989 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5990 
    args = getOrdersForItemIds_args()
5991 
    args.read(iprot)
5992 
    iprot.readMessageEnd()
5993 
    result = getOrdersForItemIds_result()
5994 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5995 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5996 
    result.write(oprot)
5997 
    oprot.writeMessageEnd()
5998 
    oprot.trans.flush()
5999 
 
4247 rajveer 6000 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6001 
    args = markOrderCancellationRequestReceived_args()
6002 
    args.read(iprot)
6003 
    iprot.readMessageEnd()
6004 
    result = markOrderCancellationRequestReceived_result()
6005 
    try:
6006 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6007 
    except TransactionServiceException, ex:
6008 
      result.ex = ex
6009 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6010 
    result.write(oprot)
6011 
    oprot.writeMessageEnd()
6012 
    oprot.trans.flush()
4018 chandransh 6013 
 
4247 rajveer 6014 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6015 
    args = markOrderCancellationRequestConfirmed_args()
6016 
    args.read(iprot)
6017 
    iprot.readMessageEnd()
6018 
    result = markOrderCancellationRequestConfirmed_result()
6019 
    try:
6020 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6021 
    except TransactionServiceException, ex:
6022 
      result.ex = ex
6023 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6024 
    result.write(oprot)
6025 
    oprot.writeMessageEnd()
6026 
    oprot.trans.flush()
6027 
 
6028 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6029 
    args = markOrderCancellationRequestDenied_args()
6030 
    args.read(iprot)
6031 
    iprot.readMessageEnd()
6032 
    result = markOrderCancellationRequestDenied_result()
6033 
    try:
6034 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6035 
    except TransactionServiceException, ex:
6036 
      result.ex = ex
6037 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6038 
    result.write(oprot)
6039 
    oprot.writeMessageEnd()
6040 
    oprot.trans.flush()
6041 
 
4258 rajveer 6042 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6043 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6044 
    args.read(iprot)
6045 
    iprot.readMessageEnd()
4258 rajveer 6046 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6047 
    try:
4258 rajveer 6048 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6049 
    except TransactionServiceException, ex:
6050 
      result.ex = ex
4258 rajveer 6051 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6052 
    result.write(oprot)
6053 
    oprot.writeMessageEnd()
6054 
    oprot.trans.flush()
6055 
 
4259 anupam.sin 6056 
  def process_refundTransaction(self, seqid, iprot, oprot):
6057 
    args = refundTransaction_args()
6058 
    args.read(iprot)
6059 
    iprot.readMessageEnd()
6060 
    result = refundTransaction_result()
6061 
    try:
6062 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6063 
    except TransactionServiceException, ex:
6064 
      result.ex = ex
6065 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6066 
    result.write(oprot)
6067 
    oprot.writeMessageEnd()
6068 
    oprot.trans.flush()
4247 rajveer 6069 
 
4324 mandeep.dh 6070 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6071 
    args = updateShipmentAddress_args()
6072 
    args.read(iprot)
6073 
    iprot.readMessageEnd()
6074 
    result = updateShipmentAddress_result()
6075 
    try:
6076 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6077 
    except TransactionServiceException, ex:
6078 
      result.ex = ex
6079 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6080 
    result.write(oprot)
6081 
    oprot.writeMessageEnd()
6082 
    oprot.trans.flush()
6083 
 
4285 rajveer 6084 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6085 
    args = acceptOrdersForItemId_args()
6086 
    args.read(iprot)
6087 
    iprot.readMessageEnd()
6088 
    result = acceptOrdersForItemId_result()
6089 
    try:
6090 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6091 
    except TransactionServiceException, ex:
6092 
      result.ex = ex
6093 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6094 
    result.write(oprot)
6095 
    oprot.writeMessageEnd()
6096 
    oprot.trans.flush()
4259 anupam.sin 6097 
 
4303 rajveer 6098 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6099 
    args = markOrdersAsPORaised_args()
6100 
    args.read(iprot)
6101 
    iprot.readMessageEnd()
6102 
    result = markOrdersAsPORaised_result()
6103 
    try:
4369 rajveer 6104 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6105 
    except TransactionServiceException, ex:
6106 
      result.ex = ex
6107 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6108 
    result.write(oprot)
6109 
    oprot.writeMessageEnd()
6110 
    oprot.trans.flush()
4285 rajveer 6111 
 
4303 rajveer 6112 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6113 
    args = markOrdersAsReversalInitiated_args()
6114 
    args.read(iprot)
6115 
    iprot.readMessageEnd()
6116 
    result = markOrdersAsReversalInitiated_result()
6117 
    try:
4369 rajveer 6118 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6119 
    except TransactionServiceException, ex:
6120 
      result.ex = ex
6121 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6122 
    result.write(oprot)
6123 
    oprot.writeMessageEnd()
6124 
    oprot.trans.flush()
6125 
 
6126 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6127 
    args = markOrdersAsNotAvailabke_args()
6128 
    args.read(iprot)
6129 
    iprot.readMessageEnd()
6130 
    result = markOrdersAsNotAvailabke_result()
6131 
    try:
4369 rajveer 6132 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6133 
    except TransactionServiceException, ex:
6134 
      result.ex = ex
6135 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6136 
    result.write(oprot)
6137 
    oprot.writeMessageEnd()
6138 
    oprot.trans.flush()
6139 
 
4369 rajveer 6140 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6141 
    args = markOrdersAsTimeout_args()
6142 
    args.read(iprot)
6143 
    iprot.readMessageEnd()
6144 
    result = markOrdersAsTimeout_result()
6145 
    try:
6146 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6147 
    except TransactionServiceException, ex:
6148 
      result.ex = ex
6149 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6150 
    result.write(oprot)
6151 
    oprot.writeMessageEnd()
6152 
    oprot.trans.flush()
4303 rajveer 6153 
 
4662 rajveer 6154 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6155 
    args = markOrderAsLostInTransit_args()
6156 
    args.read(iprot)
6157 
    iprot.readMessageEnd()
6158 
    result = markOrderAsLostInTransit_result()
6159 
    try:
6160 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6161 
    except TransactionServiceException, ex:
6162 
      result.ex = ex
6163 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6164 
    result.write(oprot)
6165 
    oprot.writeMessageEnd()
6166 
    oprot.trans.flush()
6167 
 
4386 anupam.sin 6168 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6169 
    args = getOrderForAwb_args()
6170 
    args.read(iprot)
6171 
    iprot.readMessageEnd()
6172 
    result = getOrderForAwb_result()
6173 
    try:
6174 
      result.success = self._handler.getOrderForAwb(args.awb)
6175 
    except TransactionServiceException, ex:
6176 
      result.ex = ex
6177 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6178 
    result.write(oprot)
6179 
    oprot.writeMessageEnd()
6180 
    oprot.trans.flush()
4369 rajveer 6181 
 
4506 phani.kuma 6182 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6183 
    args = getOrdersForProviderForStatus_args()
6184 
    args.read(iprot)
6185 
    iprot.readMessageEnd()
6186 
    result = getOrdersForProviderForStatus_result()
6187 
    try:
4910 phani.kuma 6188 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6189 
    except TransactionServiceException, ex:
6190 
      result.ex = ex
6191 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6192 
    result.write(oprot)
6193 
    oprot.writeMessageEnd()
6194 
    oprot.trans.flush()
4386 anupam.sin 6195 
 
4600 varun.gupt 6196 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6197 
    args = getBilledOrdersForVendor_args()
6198 
    args.read(iprot)
6199 
    iprot.readMessageEnd()
6200 
    result = getBilledOrdersForVendor_result()
6201 
    try:
6202 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6203 
    except TransactionServiceException, ex:
6204 
      result.ex = ex
6205 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6206 
    result.write(oprot)
6207 
    oprot.writeMessageEnd()
6208 
    oprot.trans.flush()
4506 phani.kuma 6209 
 
4607 rajveer 6210 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6211 
    args = getSlippedSippingDateOrders_args()
6212 
    args.read(iprot)
6213 
    iprot.readMessageEnd()
6214 
    result = getSlippedSippingDateOrders_result()
6215 
    try:
6216 
      result.success = self._handler.getSlippedSippingDateOrders()
6217 
    except TransactionServiceException, ex:
6218 
      result.ex = ex
6219 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6220 
    result.write(oprot)
6221 
    oprot.writeMessageEnd()
6222 
    oprot.trans.flush()
6223 
 
4709 rajveer 6224 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6225 
    args = getCancelledOrders_args()
6226 
    args.read(iprot)
6227 
    iprot.readMessageEnd()
6228 
    result = getCancelledOrders_result()
6229 
    try:
6230 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6231 
    except TransactionServiceException, ex:
6232 
      result.ex = ex
6233 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6234 
    result.write(oprot)
6235 
    oprot.writeMessageEnd()
6236 
    oprot.trans.flush()
6237 
 
4600 varun.gupt 6238 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6239 
    args = saveBluedartSettlements_args()
6240 
    args.read(iprot)
6241 
    iprot.readMessageEnd()
6242 
    result = saveBluedartSettlements_result()
6243 
    try:
6244 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6245 
    except TransactionServiceException, ex:
6246 
      result.ex = ex
6247 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6248 
    result.write(oprot)
6249 
    oprot.writeMessageEnd()
6250 
    oprot.trans.flush()
6251 
 
6252 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6253 
    args = savePaymentSettlements_args()
6254 
    args.read(iprot)
6255 
    iprot.readMessageEnd()
6256 
    result = savePaymentSettlements_result()
6257 
    try:
4905 varun.gupt 6258 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6259 
    except TransactionServiceException, ex:
6260 
      result.ex = ex
6261 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6262 
    result.write(oprot)
6263 
    oprot.writeMessageEnd()
6264 
    oprot.trans.flush()
6265 
 
6266 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6267 
    args = saveEBSSettlementSummary_args()
6268 
    args.read(iprot)
6269 
    iprot.readMessageEnd()
6270 
    result = saveEBSSettlementSummary_result()
6271 
    try:
6272 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6273 
    except TransactionServiceException, ex:
6274 
      result.ex = ex
6275 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6276 
    result.write(oprot)
6277 
    oprot.writeMessageEnd()
6278 
    oprot.trans.flush()
6279 
 
6280 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
6281 
    args = getSettlementForPaymentId_args()
6282 
    args.read(iprot)
6283 
    iprot.readMessageEnd()
6284 
    result = getSettlementForPaymentId_result()
6285 
    try:
6286 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
6287 
    except TransactionServiceException, ex:
6288 
      result.ex = ex
6289 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
6290 
    result.write(oprot)
6291 
    oprot.writeMessageEnd()
6292 
    oprot.trans.flush()
6293 
 
6294 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6295 
    args = getEBSSettlementSummaries_args()
6296 
    args.read(iprot)
6297 
    iprot.readMessageEnd()
6298 
    result = getEBSSettlementSummaries_result()
6299 
    try:
6300 
      result.success = self._handler.getEBSSettlementSummaries()
6301 
    except TransactionServiceException, ex:
6302 
      result.ex = ex
6303 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6304 
    result.write(oprot)
6305 
    oprot.writeMessageEnd()
6306 
    oprot.trans.flush()
6307 
 
6308 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6309 
    args = markEBSSettlementUploaded_args()
6310 
    args.read(iprot)
6311 
    iprot.readMessageEnd()
6312 
    result = markEBSSettlementUploaded_result()
6313 
    try:
6314 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6315 
    except TransactionServiceException, ex:
6316 
      result.ex = ex
6317 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6318 
    result.write(oprot)
6319 
    oprot.writeMessageEnd()
6320 
    oprot.trans.flush()
6321 
 
6322 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6323 
    args = getEBSSettlementDate_args()
6324 
    args.read(iprot)
6325 
    iprot.readMessageEnd()
6326 
    result = getEBSSettlementDate_result()
6327 
    try:
6328 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6329 
    except TransactionServiceException, ex:
6330 
      result.ex = ex
6331 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6332 
    result.write(oprot)
6333 
    oprot.writeMessageEnd()
6334 
    oprot.trans.flush()
6335 
 
4715 varun.gupt 6336 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6337 
    args = getSettlementsByDate_args()
6338 
    args.read(iprot)
6339 
    iprot.readMessageEnd()
6340 
    result = getSettlementsByDate_result()
6341 
    try:
6342 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6343 
    except TransactionServiceException, ex:
6344 
      result.ex = ex
6345 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6346 
    result.write(oprot)
6347 
    oprot.writeMessageEnd()
6348 
    oprot.trans.flush()
4600 varun.gupt 6349 
 
4715 varun.gupt 6350 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6351 
    args = getReshippedOrderIds_args()
6352 
    args.read(iprot)
6353 
    iprot.readMessageEnd()
6354 
    result = getReshippedOrderIds_result()
6355 
    try:
6356 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6357 
    except TransactionServiceException, ex:
6358 
      result.ex = ex
6359 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6360 
    result.write(oprot)
6361 
    oprot.writeMessageEnd()
6362 
    oprot.trans.flush()
6363 
 
4757 mandeep.dh 6364 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6365 
    args = updateOrdersAsPORaised_args()
6366 
    args.read(iprot)
6367 
    iprot.readMessageEnd()
6368 
    result = updateOrdersAsPORaised_result()
6369 
    try:
6370 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6371 
    except TransactionServiceException, ex:
6372 
      result.ex = ex
6373 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6374 
    result.write(oprot)
6375 
    oprot.writeMessageEnd()
6376 
    oprot.trans.flush()
4715 varun.gupt 6377 
 
4875 varun.gupt 6378 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6379 
    args = getOrdersWhereVendorNotPaid_args()
6380 
    args.read(iprot)
6381 
    iprot.readMessageEnd()
6382 
    result = getOrdersWhereVendorNotPaid_result()
6383 
    try:
6384 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6385 
    except TransactionServiceException, ex:
6386 
      result.ex = ex
6387 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
4757 mandeep.dh 6391 
 
4875 varun.gupt 6392 
 
94 ashish 6393 
# HELPER FUNCTIONS AND STRUCTURES
6394 
 
6395 
class createTransaction_args:
6396 
  """
6397 
  Attributes:
6398 
   - transaction
6399 
  """
6400 
 
6401 
  thrift_spec = (
6402 
    None, # 0
6403 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6404 
  )
6405 
 
6406 
  def __init__(self, transaction=None,):
6407 
    self.transaction = transaction
6408 
 
6409 
  def read(self, iprot):
6410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6412 
      return
6413 
    iprot.readStructBegin()
6414 
    while True:
6415 
      (fname, ftype, fid) = iprot.readFieldBegin()
6416 
      if ftype == TType.STOP:
6417 
        break
6418 
      if fid == 1:
6419 
        if ftype == TType.STRUCT:
6420 
          self.transaction = Transaction()
6421 
          self.transaction.read(iprot)
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      else:
6425 
        iprot.skip(ftype)
6426 
      iprot.readFieldEnd()
6427 
    iprot.readStructEnd()
6428 
 
6429 
  def write(self, oprot):
6430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6432 
      return
6433 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6434 
    if self.transaction is not None:
94 ashish 6435 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6436 
      self.transaction.write(oprot)
6437 
      oprot.writeFieldEnd()
6438 
    oprot.writeFieldStop()
6439 
    oprot.writeStructEnd()
6440 
 
3431 rajveer 6441 
  def validate(self):
6442 
    return
6443 
 
6444 
 
94 ashish 6445 
  def __repr__(self):
6446 
    L = ['%s=%r' % (key, value)
6447 
      for key, value in self.__dict__.iteritems()]
6448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6449 
 
6450 
  def __eq__(self, other):
6451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6452 
 
6453 
  def __ne__(self, other):
6454 
    return not (self == other)
6455 
 
6456 
class createTransaction_result:
6457 
  """
6458 
  Attributes:
132 ashish 6459 
   - success
94 ashish 6460 
   - ex
6461 
  """
6462 
 
6463 
  thrift_spec = (
132 ashish 6464 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6466 
  )
6467 
 
132 ashish 6468 
  def __init__(self, success=None, ex=None,):
6469 
    self.success = success
94 ashish 6470 
    self.ex = ex
6471 
 
6472 
  def read(self, iprot):
6473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6475 
      return
6476 
    iprot.readStructBegin()
6477 
    while True:
6478 
      (fname, ftype, fid) = iprot.readFieldBegin()
6479 
      if ftype == TType.STOP:
6480 
        break
132 ashish 6481 
      if fid == 0:
6482 
        if ftype == TType.I64:
6483 
          self.success = iprot.readI64();
6484 
        else:
6485 
          iprot.skip(ftype)
6486 
      elif fid == 1:
94 ashish 6487 
        if ftype == TType.STRUCT:
6488 
          self.ex = TransactionServiceException()
6489 
          self.ex.read(iprot)
6490 
        else:
6491 
          iprot.skip(ftype)
6492 
      else:
6493 
        iprot.skip(ftype)
6494 
      iprot.readFieldEnd()
6495 
    iprot.readStructEnd()
6496 
 
6497 
  def write(self, oprot):
6498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6500 
      return
6501 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6502 
    if self.success is not None:
132 ashish 6503 
      oprot.writeFieldBegin('success', TType.I64, 0)
6504 
      oprot.writeI64(self.success)
6505 
      oprot.writeFieldEnd()
3431 rajveer 6506 
    if self.ex is not None:
94 ashish 6507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6508 
      self.ex.write(oprot)
6509 
      oprot.writeFieldEnd()
6510 
    oprot.writeFieldStop()
6511 
    oprot.writeStructEnd()
6512 
 
3431 rajveer 6513 
  def validate(self):
6514 
    return
6515 
 
6516 
 
94 ashish 6517 
  def __repr__(self):
6518 
    L = ['%s=%r' % (key, value)
6519 
      for key, value in self.__dict__.iteritems()]
6520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6521 
 
6522 
  def __eq__(self, other):
6523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6524 
 
6525 
  def __ne__(self, other):
6526 
    return not (self == other)
6527 
 
6528 
class getTransaction_args:
6529 
  """
6530 
  Attributes:
6531 
   - id
6532 
  """
6533 
 
6534 
  thrift_spec = (
6535 
    None, # 0
6536 
    (1, TType.I64, 'id', None, None, ), # 1
6537 
  )
6538 
 
6539 
  def __init__(self, id=None,):
6540 
    self.id = id
6541 
 
6542 
  def read(self, iprot):
6543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6545 
      return
6546 
    iprot.readStructBegin()
6547 
    while True:
6548 
      (fname, ftype, fid) = iprot.readFieldBegin()
6549 
      if ftype == TType.STOP:
6550 
        break
6551 
      if fid == 1:
6552 
        if ftype == TType.I64:
6553 
          self.id = iprot.readI64();
6554 
        else:
6555 
          iprot.skip(ftype)
6556 
      else:
6557 
        iprot.skip(ftype)
6558 
      iprot.readFieldEnd()
6559 
    iprot.readStructEnd()
6560 
 
6561 
  def write(self, oprot):
6562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6564 
      return
6565 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6566 
    if self.id is not None:
94 ashish 6567 
      oprot.writeFieldBegin('id', TType.I64, 1)
6568 
      oprot.writeI64(self.id)
6569 
      oprot.writeFieldEnd()
6570 
    oprot.writeFieldStop()
6571 
    oprot.writeStructEnd()
6572 
 
3431 rajveer 6573 
  def validate(self):
6574 
    return
6575 
 
6576 
 
94 ashish 6577 
  def __repr__(self):
6578 
    L = ['%s=%r' % (key, value)
6579 
      for key, value in self.__dict__.iteritems()]
6580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6581 
 
6582 
  def __eq__(self, other):
6583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6584 
 
6585 
  def __ne__(self, other):
6586 
    return not (self == other)
6587 
 
6588 
class getTransaction_result:
6589 
  """
6590 
  Attributes:
6591 
   - success
6592 
   - ex
6593 
  """
6594 
 
6595 
  thrift_spec = (
6596 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6598 
  )
6599 
 
6600 
  def __init__(self, success=None, ex=None,):
6601 
    self.success = success
6602 
    self.ex = ex
6603 
 
6604 
  def read(self, iprot):
6605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6607 
      return
6608 
    iprot.readStructBegin()
6609 
    while True:
6610 
      (fname, ftype, fid) = iprot.readFieldBegin()
6611 
      if ftype == TType.STOP:
6612 
        break
6613 
      if fid == 0:
6614 
        if ftype == TType.STRUCT:
6615 
          self.success = Transaction()
6616 
          self.success.read(iprot)
6617 
        else:
6618 
          iprot.skip(ftype)
6619 
      elif fid == 1:
6620 
        if ftype == TType.STRUCT:
6621 
          self.ex = TransactionServiceException()
6622 
          self.ex.read(iprot)
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      else:
6626 
        iprot.skip(ftype)
6627 
      iprot.readFieldEnd()
6628 
    iprot.readStructEnd()
6629 
 
6630 
  def write(self, oprot):
6631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6633 
      return
6634 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6635 
    if self.success is not None:
94 ashish 6636 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6637 
      self.success.write(oprot)
6638 
      oprot.writeFieldEnd()
3431 rajveer 6639 
    if self.ex is not None:
94 ashish 6640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6641 
      self.ex.write(oprot)
6642 
      oprot.writeFieldEnd()
6643 
    oprot.writeFieldStop()
6644 
    oprot.writeStructEnd()
6645 
 
3431 rajveer 6646 
  def validate(self):
6647 
    return
6648 
 
6649 
 
94 ashish 6650 
  def __repr__(self):
6651 
    L = ['%s=%r' % (key, value)
6652 
      for key, value in self.__dict__.iteritems()]
6653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6654 
 
6655 
  def __eq__(self, other):
6656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6657 
 
6658 
  def __ne__(self, other):
6659 
    return not (self == other)
6660 
 
6661 
class getTransactionsForCustomer_args:
6662 
  """
6663 
  Attributes:
6664 
   - customerId
6665 
   - from_date
6666 
   - to_date
6667 
   - status
6668 
  """
6669 
 
6670 
  thrift_spec = (
6671 
    None, # 0
6672 
    (1, TType.I64, 'customerId', None, None, ), # 1
6673 
    (2, TType.I64, 'from_date', None, None, ), # 2
6674 
    (3, TType.I64, 'to_date', None, None, ), # 3
6675 
    (4, TType.I32, 'status', None, None, ), # 4
6676 
  )
6677 
 
6678 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6679 
    self.customerId = customerId
6680 
    self.from_date = from_date
6681 
    self.to_date = to_date
6682 
    self.status = status
6683 
 
6684 
  def read(self, iprot):
6685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6687 
      return
6688 
    iprot.readStructBegin()
6689 
    while True:
6690 
      (fname, ftype, fid) = iprot.readFieldBegin()
6691 
      if ftype == TType.STOP:
6692 
        break
6693 
      if fid == 1:
6694 
        if ftype == TType.I64:
6695 
          self.customerId = iprot.readI64();
6696 
        else:
6697 
          iprot.skip(ftype)
6698 
      elif fid == 2:
6699 
        if ftype == TType.I64:
6700 
          self.from_date = iprot.readI64();
6701 
        else:
6702 
          iprot.skip(ftype)
6703 
      elif fid == 3:
6704 
        if ftype == TType.I64:
6705 
          self.to_date = iprot.readI64();
6706 
        else:
6707 
          iprot.skip(ftype)
6708 
      elif fid == 4:
6709 
        if ftype == TType.I32:
6710 
          self.status = iprot.readI32();
6711 
        else:
6712 
          iprot.skip(ftype)
6713 
      else:
6714 
        iprot.skip(ftype)
6715 
      iprot.readFieldEnd()
6716 
    iprot.readStructEnd()
6717 
 
6718 
  def write(self, oprot):
6719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6721 
      return
6722 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6723 
    if self.customerId is not None:
94 ashish 6724 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6725 
      oprot.writeI64(self.customerId)
6726 
      oprot.writeFieldEnd()
3431 rajveer 6727 
    if self.from_date is not None:
94 ashish 6728 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6729 
      oprot.writeI64(self.from_date)
6730 
      oprot.writeFieldEnd()
3431 rajveer 6731 
    if self.to_date is not None:
94 ashish 6732 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6733 
      oprot.writeI64(self.to_date)
6734 
      oprot.writeFieldEnd()
3431 rajveer 6735 
    if self.status is not None:
94 ashish 6736 
      oprot.writeFieldBegin('status', TType.I32, 4)
6737 
      oprot.writeI32(self.status)
6738 
      oprot.writeFieldEnd()
6739 
    oprot.writeFieldStop()
6740 
    oprot.writeStructEnd()
6741 
 
3431 rajveer 6742 
  def validate(self):
6743 
    return
6744 
 
6745 
 
94 ashish 6746 
  def __repr__(self):
6747 
    L = ['%s=%r' % (key, value)
6748 
      for key, value in self.__dict__.iteritems()]
6749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6750 
 
6751 
  def __eq__(self, other):
6752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6753 
 
6754 
  def __ne__(self, other):
6755 
    return not (self == other)
6756 
 
6757 
class getTransactionsForCustomer_result:
6758 
  """
6759 
  Attributes:
6760 
   - success
6761 
   - ex
6762 
  """
6763 
 
6764 
  thrift_spec = (
6765 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6767 
  )
6768 
 
6769 
  def __init__(self, success=None, ex=None,):
6770 
    self.success = success
6771 
    self.ex = ex
6772 
 
6773 
  def read(self, iprot):
6774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6776 
      return
6777 
    iprot.readStructBegin()
6778 
    while True:
6779 
      (fname, ftype, fid) = iprot.readFieldBegin()
6780 
      if ftype == TType.STOP:
6781 
        break
6782 
      if fid == 0:
6783 
        if ftype == TType.LIST:
6784 
          self.success = []
4983 phani.kuma 6785 
          (_etype59, _size56) = iprot.readListBegin()
6786 
          for _i60 in xrange(_size56):
6787 
            _elem61 = Transaction()
6788 
            _elem61.read(iprot)
6789 
            self.success.append(_elem61)
94 ashish 6790 
          iprot.readListEnd()
6791 
        else:
6792 
          iprot.skip(ftype)
6793 
      elif fid == 1:
6794 
        if ftype == TType.STRUCT:
6795 
          self.ex = TransactionServiceException()
6796 
          self.ex.read(iprot)
6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      else:
6800 
        iprot.skip(ftype)
6801 
      iprot.readFieldEnd()
6802 
    iprot.readStructEnd()
6803 
 
6804 
  def write(self, oprot):
6805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6807 
      return
6808 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6809 
    if self.success is not None:
94 ashish 6810 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6811 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 6812 
      for iter62 in self.success:
6813 
        iter62.write(oprot)
94 ashish 6814 
      oprot.writeListEnd()
6815 
      oprot.writeFieldEnd()
3431 rajveer 6816 
    if self.ex is not None:
94 ashish 6817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6818 
      self.ex.write(oprot)
6819 
      oprot.writeFieldEnd()
6820 
    oprot.writeFieldStop()
6821 
    oprot.writeStructEnd()
6822 
 
3431 rajveer 6823 
  def validate(self):
6824 
    return
6825 
 
6826 
 
94 ashish 6827 
  def __repr__(self):
6828 
    L = ['%s=%r' % (key, value)
6829 
      for key, value in self.__dict__.iteritems()]
6830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6831 
 
6832 
  def __eq__(self, other):
6833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6834 
 
6835 
  def __ne__(self, other):
6836 
    return not (self == other)
6837 
 
132 ashish 6838 
class getTransactionsForShoppingCartId_args:
6839 
  """
6840 
  Attributes:
6841 
   - shoppingCartId
6842 
  """
6843 
 
6844 
  thrift_spec = (
6845 
    None, # 0
6846 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6847 
  )
6848 
 
6849 
  def __init__(self, shoppingCartId=None,):
6850 
    self.shoppingCartId = shoppingCartId
6851 
 
6852 
  def read(self, iprot):
6853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6855 
      return
6856 
    iprot.readStructBegin()
6857 
    while True:
6858 
      (fname, ftype, fid) = iprot.readFieldBegin()
6859 
      if ftype == TType.STOP:
6860 
        break
6861 
      if fid == 1:
6862 
        if ftype == TType.I64:
6863 
          self.shoppingCartId = iprot.readI64();
6864 
        else:
6865 
          iprot.skip(ftype)
6866 
      else:
6867 
        iprot.skip(ftype)
6868 
      iprot.readFieldEnd()
6869 
    iprot.readStructEnd()
6870 
 
6871 
  def write(self, oprot):
6872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6874 
      return
6875 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6876 
    if self.shoppingCartId is not None:
132 ashish 6877 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6878 
      oprot.writeI64(self.shoppingCartId)
6879 
      oprot.writeFieldEnd()
6880 
    oprot.writeFieldStop()
6881 
    oprot.writeStructEnd()
6882 
 
3431 rajveer 6883 
  def validate(self):
6884 
    return
6885 
 
6886 
 
132 ashish 6887 
  def __repr__(self):
6888 
    L = ['%s=%r' % (key, value)
6889 
      for key, value in self.__dict__.iteritems()]
6890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6891 
 
6892 
  def __eq__(self, other):
6893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6894 
 
6895 
  def __ne__(self, other):
6896 
    return not (self == other)
6897 
 
6898 
class getTransactionsForShoppingCartId_result:
6899 
  """
6900 
  Attributes:
6901 
   - success
6902 
   - ex
6903 
  """
6904 
 
6905 
  thrift_spec = (
6906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6908 
  )
6909 
 
6910 
  def __init__(self, success=None, ex=None,):
6911 
    self.success = success
6912 
    self.ex = ex
6913 
 
6914 
  def read(self, iprot):
6915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6917 
      return
6918 
    iprot.readStructBegin()
6919 
    while True:
6920 
      (fname, ftype, fid) = iprot.readFieldBegin()
6921 
      if ftype == TType.STOP:
6922 
        break
6923 
      if fid == 0:
6924 
        if ftype == TType.LIST:
6925 
          self.success = []
4983 phani.kuma 6926 
          (_etype66, _size63) = iprot.readListBegin()
6927 
          for _i67 in xrange(_size63):
6928 
            _elem68 = Transaction()
6929 
            _elem68.read(iprot)
6930 
            self.success.append(_elem68)
132 ashish 6931 
          iprot.readListEnd()
6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      elif fid == 1:
6935 
        if ftype == TType.STRUCT:
6936 
          self.ex = TransactionServiceException()
6937 
          self.ex.read(iprot)
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
6949 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6950 
    if self.success is not None:
132 ashish 6951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 6953 
      for iter69 in self.success:
6954 
        iter69.write(oprot)
132 ashish 6955 
      oprot.writeListEnd()
6956 
      oprot.writeFieldEnd()
3431 rajveer 6957 
    if self.ex is not None:
132 ashish 6958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6959 
      self.ex.write(oprot)
6960 
      oprot.writeFieldEnd()
6961 
    oprot.writeFieldStop()
6962 
    oprot.writeStructEnd()
6963 
 
3431 rajveer 6964 
  def validate(self):
6965 
    return
6966 
 
6967 
 
132 ashish 6968 
  def __repr__(self):
6969 
    L = ['%s=%r' % (key, value)
6970 
      for key, value in self.__dict__.iteritems()]
6971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6972 
 
6973 
  def __eq__(self, other):
6974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6975 
 
6976 
  def __ne__(self, other):
6977 
    return not (self == other)
6978 
 
94 ashish 6979 
class getTransactionStatus_args:
6980 
  """
6981 
  Attributes:
6982 
   - transactionId
6983 
  """
6984 
 
6985 
  thrift_spec = (
6986 
    None, # 0
6987 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6988 
  )
6989 
 
6990 
  def __init__(self, transactionId=None,):
6991 
    self.transactionId = transactionId
6992 
 
6993 
  def read(self, iprot):
6994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6996 
      return
6997 
    iprot.readStructBegin()
6998 
    while True:
6999 
      (fname, ftype, fid) = iprot.readFieldBegin()
7000 
      if ftype == TType.STOP:
7001 
        break
7002 
      if fid == 1:
7003 
        if ftype == TType.I64:
7004 
          self.transactionId = iprot.readI64();
7005 
        else:
7006 
          iprot.skip(ftype)
7007 
      else:
7008 
        iprot.skip(ftype)
7009 
      iprot.readFieldEnd()
7010 
    iprot.readStructEnd()
7011 
 
7012 
  def write(self, oprot):
7013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7015 
      return
7016 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7017 
    if self.transactionId is not None:
94 ashish 7018 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7019 
      oprot.writeI64(self.transactionId)
7020 
      oprot.writeFieldEnd()
7021 
    oprot.writeFieldStop()
7022 
    oprot.writeStructEnd()
7023 
 
3431 rajveer 7024 
  def validate(self):
7025 
    return
7026 
 
7027 
 
94 ashish 7028 
  def __repr__(self):
7029 
    L = ['%s=%r' % (key, value)
7030 
      for key, value in self.__dict__.iteritems()]
7031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7032 
 
7033 
  def __eq__(self, other):
7034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7035 
 
7036 
  def __ne__(self, other):
7037 
    return not (self == other)
7038 
 
7039 
class getTransactionStatus_result:
7040 
  """
7041 
  Attributes:
7042 
   - success
7043 
   - ex
7044 
  """
7045 
 
7046 
  thrift_spec = (
7047 
    (0, TType.I32, 'success', None, None, ), # 0
7048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7049 
  )
7050 
 
7051 
  def __init__(self, success=None, ex=None,):
7052 
    self.success = success
7053 
    self.ex = ex
7054 
 
7055 
  def read(self, iprot):
7056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7058 
      return
7059 
    iprot.readStructBegin()
7060 
    while True:
7061 
      (fname, ftype, fid) = iprot.readFieldBegin()
7062 
      if ftype == TType.STOP:
7063 
        break
7064 
      if fid == 0:
7065 
        if ftype == TType.I32:
7066 
          self.success = iprot.readI32();
7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      elif fid == 1:
7070 
        if ftype == TType.STRUCT:
7071 
          self.ex = TransactionServiceException()
7072 
          self.ex.read(iprot)
7073 
        else:
7074 
          iprot.skip(ftype)
7075 
      else:
7076 
        iprot.skip(ftype)
7077 
      iprot.readFieldEnd()
7078 
    iprot.readStructEnd()
7079 
 
7080 
  def write(self, oprot):
7081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7083 
      return
7084 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7085 
    if self.success is not None:
94 ashish 7086 
      oprot.writeFieldBegin('success', TType.I32, 0)
7087 
      oprot.writeI32(self.success)
7088 
      oprot.writeFieldEnd()
3431 rajveer 7089 
    if self.ex is not None:
94 ashish 7090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7091 
      self.ex.write(oprot)
7092 
      oprot.writeFieldEnd()
7093 
    oprot.writeFieldStop()
7094 
    oprot.writeStructEnd()
7095 
 
3431 rajveer 7096 
  def validate(self):
7097 
    return
7098 
 
7099 
 
94 ashish 7100 
  def __repr__(self):
7101 
    L = ['%s=%r' % (key, value)
7102 
      for key, value in self.__dict__.iteritems()]
7103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7104 
 
7105 
  def __eq__(self, other):
7106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7107 
 
7108 
  def __ne__(self, other):
7109 
    return not (self == other)
7110 
 
7111 
class changeTransactionStatus_args:
7112 
  """
7113 
  Attributes:
7114 
   - transactionId
7115 
   - status
7116 
   - description
7117 
  """
7118 
 
7119 
  thrift_spec = (
7120 
    None, # 0
7121 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7122 
    (2, TType.I32, 'status', None, None, ), # 2
7123 
    (3, TType.STRING, 'description', None, None, ), # 3
7124 
  )
7125 
 
7126 
  def __init__(self, transactionId=None, status=None, description=None,):
7127 
    self.transactionId = transactionId
7128 
    self.status = status
7129 
    self.description = description
7130 
 
7131 
  def read(self, iprot):
7132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7134 
      return
7135 
    iprot.readStructBegin()
7136 
    while True:
7137 
      (fname, ftype, fid) = iprot.readFieldBegin()
7138 
      if ftype == TType.STOP:
7139 
        break
7140 
      if fid == 1:
7141 
        if ftype == TType.I64:
7142 
          self.transactionId = iprot.readI64();
7143 
        else:
7144 
          iprot.skip(ftype)
7145 
      elif fid == 2:
7146 
        if ftype == TType.I32:
7147 
          self.status = iprot.readI32();
7148 
        else:
7149 
          iprot.skip(ftype)
7150 
      elif fid == 3:
7151 
        if ftype == TType.STRING:
7152 
          self.description = iprot.readString();
7153 
        else:
7154 
          iprot.skip(ftype)
7155 
      else:
7156 
        iprot.skip(ftype)
7157 
      iprot.readFieldEnd()
7158 
    iprot.readStructEnd()
7159 
 
7160 
  def write(self, oprot):
7161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7163 
      return
7164 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7165 
    if self.transactionId is not None:
94 ashish 7166 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7167 
      oprot.writeI64(self.transactionId)
7168 
      oprot.writeFieldEnd()
3431 rajveer 7169 
    if self.status is not None:
94 ashish 7170 
      oprot.writeFieldBegin('status', TType.I32, 2)
7171 
      oprot.writeI32(self.status)
7172 
      oprot.writeFieldEnd()
3431 rajveer 7173 
    if self.description is not None:
94 ashish 7174 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7175 
      oprot.writeString(self.description)
7176 
      oprot.writeFieldEnd()
7177 
    oprot.writeFieldStop()
7178 
    oprot.writeStructEnd()
7179 
 
3431 rajveer 7180 
  def validate(self):
7181 
    return
7182 
 
7183 
 
94 ashish 7184 
  def __repr__(self):
7185 
    L = ['%s=%r' % (key, value)
7186 
      for key, value in self.__dict__.iteritems()]
7187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7188 
 
7189 
  def __eq__(self, other):
7190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7191 
 
7192 
  def __ne__(self, other):
7193 
    return not (self == other)
7194 
 
7195 
class changeTransactionStatus_result:
7196 
  """
7197 
  Attributes:
7198 
   - success
7199 
   - ex
7200 
  """
7201 
 
7202 
  thrift_spec = (
7203 
    (0, TType.BOOL, 'success', None, None, ), # 0
7204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7205 
  )
7206 
 
7207 
  def __init__(self, success=None, ex=None,):
7208 
    self.success = success
7209 
    self.ex = ex
7210 
 
7211 
  def read(self, iprot):
7212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7214 
      return
7215 
    iprot.readStructBegin()
7216 
    while True:
7217 
      (fname, ftype, fid) = iprot.readFieldBegin()
7218 
      if ftype == TType.STOP:
7219 
        break
7220 
      if fid == 0:
7221 
        if ftype == TType.BOOL:
7222 
          self.success = iprot.readBool();
7223 
        else:
7224 
          iprot.skip(ftype)
7225 
      elif fid == 1:
7226 
        if ftype == TType.STRUCT:
7227 
          self.ex = TransactionServiceException()
7228 
          self.ex.read(iprot)
7229 
        else:
7230 
          iprot.skip(ftype)
7231 
      else:
7232 
        iprot.skip(ftype)
7233 
      iprot.readFieldEnd()
7234 
    iprot.readStructEnd()
7235 
 
7236 
  def write(self, oprot):
7237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7239 
      return
7240 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7241 
    if self.success is not None:
94 ashish 7242 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7243 
      oprot.writeBool(self.success)
7244 
      oprot.writeFieldEnd()
3431 rajveer 7245 
    if self.ex is not None:
94 ashish 7246 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7247 
      self.ex.write(oprot)
7248 
      oprot.writeFieldEnd()
7249 
    oprot.writeFieldStop()
7250 
    oprot.writeStructEnd()
7251 
 
3431 rajveer 7252 
  def validate(self):
7253 
    return
7254 
 
7255 
 
94 ashish 7256 
  def __repr__(self):
7257 
    L = ['%s=%r' % (key, value)
7258 
      for key, value in self.__dict__.iteritems()]
7259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7260 
 
7261 
  def __eq__(self, other):
7262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7263 
 
7264 
  def __ne__(self, other):
7265 
    return not (self == other)
7266 
 
1398 varun.gupt 7267 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7268 
  """
7269 
  Attributes:
7270 
   - transactionId
7271 
  """
7272 
 
7273 
  thrift_spec = (
7274 
    None, # 0
7275 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7276 
  )
7277 
 
7278 
  def __init__(self, transactionId=None,):
7279 
    self.transactionId = transactionId
7280 
 
7281 
  def read(self, iprot):
7282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7284 
      return
7285 
    iprot.readStructBegin()
7286 
    while True:
7287 
      (fname, ftype, fid) = iprot.readFieldBegin()
7288 
      if ftype == TType.STOP:
7289 
        break
7290 
      if fid == 1:
7291 
        if ftype == TType.I64:
7292 
          self.transactionId = iprot.readI64();
7293 
        else:
7294 
          iprot.skip(ftype)
7295 
      else:
7296 
        iprot.skip(ftype)
7297 
      iprot.readFieldEnd()
7298 
    iprot.readStructEnd()
7299 
 
7300 
  def write(self, oprot):
7301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7303 
      return
1398 varun.gupt 7304 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7305 
    if self.transactionId is not None:
1382 varun.gupt 7306 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7307 
      oprot.writeI64(self.transactionId)
7308 
      oprot.writeFieldEnd()
7309 
    oprot.writeFieldStop()
7310 
    oprot.writeStructEnd()
7311 
 
3431 rajveer 7312 
  def validate(self):
7313 
    return
7314 
 
7315 
 
1382 varun.gupt 7316 
  def __repr__(self):
7317 
    L = ['%s=%r' % (key, value)
7318 
      for key, value in self.__dict__.iteritems()]
7319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7320 
 
7321 
  def __eq__(self, other):
7322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7323 
 
7324 
  def __ne__(self, other):
7325 
    return not (self == other)
7326 
 
1398 varun.gupt 7327 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7328 
  """
7329 
  Attributes:
7330 
   - success
7331 
   - ex
7332 
  """
7333 
 
7334 
  thrift_spec = (
7335 
    (0, TType.BOOL, 'success', None, None, ), # 0
7336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7337 
  )
7338 
 
7339 
  def __init__(self, success=None, ex=None,):
7340 
    self.success = success
7341 
    self.ex = ex
7342 
 
7343 
  def read(self, iprot):
7344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7346 
      return
7347 
    iprot.readStructBegin()
7348 
    while True:
7349 
      (fname, ftype, fid) = iprot.readFieldBegin()
7350 
      if ftype == TType.STOP:
7351 
        break
7352 
      if fid == 0:
7353 
        if ftype == TType.BOOL:
7354 
          self.success = iprot.readBool();
7355 
        else:
7356 
          iprot.skip(ftype)
7357 
      elif fid == 1:
7358 
        if ftype == TType.STRUCT:
7359 
          self.ex = TransactionServiceException()
7360 
          self.ex.read(iprot)
7361 
        else:
7362 
          iprot.skip(ftype)
7363 
      else:
7364 
        iprot.skip(ftype)
7365 
      iprot.readFieldEnd()
7366 
    iprot.readStructEnd()
7367 
 
7368 
  def write(self, oprot):
7369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7371 
      return
1398 varun.gupt 7372 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7373 
    if self.success is not None:
1382 varun.gupt 7374 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7375 
      oprot.writeBool(self.success)
7376 
      oprot.writeFieldEnd()
3431 rajveer 7377 
    if self.ex is not None:
1382 varun.gupt 7378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7379 
      self.ex.write(oprot)
7380 
      oprot.writeFieldEnd()
7381 
    oprot.writeFieldStop()
7382 
    oprot.writeStructEnd()
7383 
 
3431 rajveer 7384 
  def validate(self):
7385 
    return
7386 
 
7387 
 
1382 varun.gupt 7388 
  def __repr__(self):
7389 
    L = ['%s=%r' % (key, value)
7390 
      for key, value in self.__dict__.iteritems()]
7391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7392 
 
7393 
  def __eq__(self, other):
7394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7395 
 
7396 
  def __ne__(self, other):
7397 
    return not (self == other)
7398 
 
483 rajveer 7399 
class getAllOrders_args:
94 ashish 7400 
  """
7401 
  Attributes:
4801 anupam.sin 7402 
   - statuses
483 rajveer 7403 
   - from_date
7404 
   - to_date
7405 
   - warehouse_id
94 ashish 7406 
  """
7407 
 
7408 
  thrift_spec = (
7409 
    None, # 0
4801 anupam.sin 7410 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7411 
    (2, TType.I64, 'from_date', None, None, ), # 2
7412 
    (3, TType.I64, 'to_date', None, None, ), # 3
7413 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7414 
  )
7415 
 
4801 anupam.sin 7416 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7417 
    self.statuses = statuses
483 rajveer 7418 
    self.from_date = from_date
7419 
    self.to_date = to_date
7420 
    self.warehouse_id = warehouse_id
94 ashish 7421 
 
7422 
  def read(self, iprot):
7423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7425 
      return
7426 
    iprot.readStructBegin()
7427 
    while True:
7428 
      (fname, ftype, fid) = iprot.readFieldBegin()
7429 
      if ftype == TType.STOP:
7430 
        break
7431 
      if fid == 1:
4801 anupam.sin 7432 
        if ftype == TType.LIST:
7433 
          self.statuses = []
4983 phani.kuma 7434 
          (_etype73, _size70) = iprot.readListBegin()
7435 
          for _i74 in xrange(_size70):
7436 
            _elem75 = iprot.readI32();
7437 
            self.statuses.append(_elem75)
4801 anupam.sin 7438 
          iprot.readListEnd()
94 ashish 7439 
        else:
7440 
          iprot.skip(ftype)
483 rajveer 7441 
      elif fid == 2:
7442 
        if ftype == TType.I64:
7443 
          self.from_date = iprot.readI64();
94 ashish 7444 
        else:
7445 
          iprot.skip(ftype)
483 rajveer 7446 
      elif fid == 3:
7447 
        if ftype == TType.I64:
7448 
          self.to_date = iprot.readI64();
94 ashish 7449 
        else:
7450 
          iprot.skip(ftype)
483 rajveer 7451 
      elif fid == 4:
94 ashish 7452 
        if ftype == TType.I64:
483 rajveer 7453 
          self.warehouse_id = iprot.readI64();
94 ashish 7454 
        else:
7455 
          iprot.skip(ftype)
7456 
      else:
7457 
        iprot.skip(ftype)
7458 
      iprot.readFieldEnd()
7459 
    iprot.readStructEnd()
7460 
 
7461 
  def write(self, oprot):
7462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7464 
      return
483 rajveer 7465 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7466 
    if self.statuses is not None:
7467 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7468 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4983 phani.kuma 7469 
      for iter76 in self.statuses:
7470 
        oprot.writeI32(iter76)
4801 anupam.sin 7471 
      oprot.writeListEnd()
94 ashish 7472 
      oprot.writeFieldEnd()
3431 rajveer 7473 
    if self.from_date is not None:
483 rajveer 7474 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7475 
      oprot.writeI64(self.from_date)
94 ashish 7476 
      oprot.writeFieldEnd()
3431 rajveer 7477 
    if self.to_date is not None:
483 rajveer 7478 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7479 
      oprot.writeI64(self.to_date)
94 ashish 7480 
      oprot.writeFieldEnd()
3431 rajveer 7481 
    if self.warehouse_id is not None:
483 rajveer 7482 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7483 
      oprot.writeI64(self.warehouse_id)
94 ashish 7484 
      oprot.writeFieldEnd()
7485 
    oprot.writeFieldStop()
7486 
    oprot.writeStructEnd()
7487 
 
3431 rajveer 7488 
  def validate(self):
7489 
    return
7490 
 
7491 
 
94 ashish 7492 
  def __repr__(self):
7493 
    L = ['%s=%r' % (key, value)
7494 
      for key, value in self.__dict__.iteritems()]
7495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7496 
 
7497 
  def __eq__(self, other):
7498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7499 
 
7500 
  def __ne__(self, other):
7501 
    return not (self == other)
7502 
 
483 rajveer 7503 
class getAllOrders_result:
94 ashish 7504 
  """
7505 
  Attributes:
7506 
   - success
7507 
   - ex
7508 
  """
7509 
 
7510 
  thrift_spec = (
483 rajveer 7511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7512 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7513 
  )
7514 
 
7515 
  def __init__(self, success=None, ex=None,):
7516 
    self.success = success
7517 
    self.ex = ex
7518 
 
7519 
  def read(self, iprot):
7520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7522 
      return
7523 
    iprot.readStructBegin()
7524 
    while True:
7525 
      (fname, ftype, fid) = iprot.readFieldBegin()
7526 
      if ftype == TType.STOP:
7527 
        break
7528 
      if fid == 0:
483 rajveer 7529 
        if ftype == TType.LIST:
7530 
          self.success = []
4983 phani.kuma 7531 
          (_etype80, _size77) = iprot.readListBegin()
7532 
          for _i81 in xrange(_size77):
7533 
            _elem82 = Order()
7534 
            _elem82.read(iprot)
7535 
            self.success.append(_elem82)
483 rajveer 7536 
          iprot.readListEnd()
94 ashish 7537 
        else:
7538 
          iprot.skip(ftype)
7539 
      elif fid == 1:
7540 
        if ftype == TType.STRUCT:
7541 
          self.ex = TransactionServiceException()
7542 
          self.ex.read(iprot)
7543 
        else:
7544 
          iprot.skip(ftype)
7545 
      else:
7546 
        iprot.skip(ftype)
7547 
      iprot.readFieldEnd()
7548 
    iprot.readStructEnd()
7549 
 
7550 
  def write(self, oprot):
7551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7553 
      return
483 rajveer 7554 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7555 
    if self.success is not None:
483 rajveer 7556 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7557 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 7558 
      for iter83 in self.success:
7559 
        iter83.write(oprot)
483 rajveer 7560 
      oprot.writeListEnd()
94 ashish 7561 
      oprot.writeFieldEnd()
3431 rajveer 7562 
    if self.ex is not None:
94 ashish 7563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7564 
      self.ex.write(oprot)
7565 
      oprot.writeFieldEnd()
7566 
    oprot.writeFieldStop()
7567 
    oprot.writeStructEnd()
7568 
 
3431 rajveer 7569 
  def validate(self):
7570 
    return
7571 
 
7572 
 
94 ashish 7573 
  def __repr__(self):
7574 
    L = ['%s=%r' % (key, value)
7575 
      for key, value in self.__dict__.iteritems()]
7576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7577 
 
7578 
  def __eq__(self, other):
7579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7580 
 
7581 
  def __ne__(self, other):
7582 
    return not (self == other)
7583 
 
4133 chandransh 7584 
class getOrdersInBatch_args:
7585 
  """
7586 
  Attributes:
7587 
   - statuses
7588 
   - offset
7589 
   - limit
7590 
   - warehouse_id
7591 
  """
7592 
 
7593 
  thrift_spec = (
7594 
    None, # 0
7595 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7596 
    (2, TType.I64, 'offset', None, None, ), # 2
7597 
    (3, TType.I64, 'limit', None, None, ), # 3
7598 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7599 
  )
7600 
 
7601 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7602 
    self.statuses = statuses
7603 
    self.offset = offset
7604 
    self.limit = limit
7605 
    self.warehouse_id = warehouse_id
7606 
 
7607 
  def read(self, iprot):
7608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7610 
      return
7611 
    iprot.readStructBegin()
7612 
    while True:
7613 
      (fname, ftype, fid) = iprot.readFieldBegin()
7614 
      if ftype == TType.STOP:
7615 
        break
7616 
      if fid == 1:
7617 
        if ftype == TType.LIST:
7618 
          self.statuses = []
4983 phani.kuma 7619 
          (_etype87, _size84) = iprot.readListBegin()
7620 
          for _i88 in xrange(_size84):
7621 
            _elem89 = iprot.readI32();
7622 
            self.statuses.append(_elem89)
4133 chandransh 7623 
          iprot.readListEnd()
7624 
        else:
7625 
          iprot.skip(ftype)
7626 
      elif fid == 2:
7627 
        if ftype == TType.I64:
7628 
          self.offset = iprot.readI64();
7629 
        else:
7630 
          iprot.skip(ftype)
7631 
      elif fid == 3:
7632 
        if ftype == TType.I64:
7633 
          self.limit = iprot.readI64();
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      elif fid == 4:
7637 
        if ftype == TType.I64:
7638 
          self.warehouse_id = iprot.readI64();
7639 
        else:
7640 
          iprot.skip(ftype)
7641 
      else:
7642 
        iprot.skip(ftype)
7643 
      iprot.readFieldEnd()
7644 
    iprot.readStructEnd()
7645 
 
7646 
  def write(self, oprot):
7647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7649 
      return
7650 
    oprot.writeStructBegin('getOrdersInBatch_args')
7651 
    if self.statuses is not None:
7652 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7653 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4983 phani.kuma 7654 
      for iter90 in self.statuses:
7655 
        oprot.writeI32(iter90)
4133 chandransh 7656 
      oprot.writeListEnd()
7657 
      oprot.writeFieldEnd()
7658 
    if self.offset is not None:
7659 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7660 
      oprot.writeI64(self.offset)
7661 
      oprot.writeFieldEnd()
7662 
    if self.limit is not None:
7663 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7664 
      oprot.writeI64(self.limit)
7665 
      oprot.writeFieldEnd()
7666 
    if self.warehouse_id is not None:
7667 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7668 
      oprot.writeI64(self.warehouse_id)
7669 
      oprot.writeFieldEnd()
7670 
    oprot.writeFieldStop()
7671 
    oprot.writeStructEnd()
7672 
 
7673 
  def validate(self):
7674 
    return
7675 
 
7676 
 
7677 
  def __repr__(self):
7678 
    L = ['%s=%r' % (key, value)
7679 
      for key, value in self.__dict__.iteritems()]
7680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7681 
 
7682 
  def __eq__(self, other):
7683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7684 
 
7685 
  def __ne__(self, other):
7686 
    return not (self == other)
7687 
 
7688 
class getOrdersInBatch_result:
7689 
  """
7690 
  Attributes:
7691 
   - success
7692 
   - ex
7693 
  """
7694 
 
7695 
  thrift_spec = (
7696 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7698 
  )
7699 
 
7700 
  def __init__(self, success=None, ex=None,):
7701 
    self.success = success
7702 
    self.ex = ex
7703 
 
7704 
  def read(self, iprot):
7705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7707 
      return
7708 
    iprot.readStructBegin()
7709 
    while True:
7710 
      (fname, ftype, fid) = iprot.readFieldBegin()
7711 
      if ftype == TType.STOP:
7712 
        break
7713 
      if fid == 0:
7714 
        if ftype == TType.LIST:
7715 
          self.success = []
4983 phani.kuma 7716 
          (_etype94, _size91) = iprot.readListBegin()
7717 
          for _i95 in xrange(_size91):
7718 
            _elem96 = Order()
7719 
            _elem96.read(iprot)
7720 
            self.success.append(_elem96)
4133 chandransh 7721 
          iprot.readListEnd()
7722 
        else:
7723 
          iprot.skip(ftype)
7724 
      elif fid == 1:
7725 
        if ftype == TType.STRUCT:
7726 
          self.ex = TransactionServiceException()
7727 
          self.ex.read(iprot)
7728 
        else:
7729 
          iprot.skip(ftype)
7730 
      else:
7731 
        iprot.skip(ftype)
7732 
      iprot.readFieldEnd()
7733 
    iprot.readStructEnd()
7734 
 
7735 
  def write(self, oprot):
7736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7738 
      return
7739 
    oprot.writeStructBegin('getOrdersInBatch_result')
7740 
    if self.success is not None:
7741 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7742 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 7743 
      for iter97 in self.success:
7744 
        iter97.write(oprot)
4133 chandransh 7745 
      oprot.writeListEnd()
7746 
      oprot.writeFieldEnd()
7747 
    if self.ex is not None:
7748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7749 
      self.ex.write(oprot)
7750 
      oprot.writeFieldEnd()
7751 
    oprot.writeFieldStop()
7752 
    oprot.writeStructEnd()
7753 
 
7754 
  def validate(self):
7755 
    return
7756 
 
7757 
 
7758 
  def __repr__(self):
7759 
    L = ['%s=%r' % (key, value)
7760 
      for key, value in self.__dict__.iteritems()]
7761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7762 
 
7763 
  def __eq__(self, other):
7764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7765 
 
7766 
  def __ne__(self, other):
7767 
    return not (self == other)
7768 
 
7769 
class getOrderCount_args:
7770 
  """
7771 
  Attributes:
7772 
   - statuses
7773 
   - warehouseId
7774 
  """
7775 
 
7776 
  thrift_spec = (
7777 
    None, # 0
7778 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7779 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7780 
  )
7781 
 
7782 
  def __init__(self, statuses=None, warehouseId=None,):
7783 
    self.statuses = statuses
7784 
    self.warehouseId = warehouseId
7785 
 
7786 
  def read(self, iprot):
7787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7789 
      return
7790 
    iprot.readStructBegin()
7791 
    while True:
7792 
      (fname, ftype, fid) = iprot.readFieldBegin()
7793 
      if ftype == TType.STOP:
7794 
        break
7795 
      if fid == 1:
7796 
        if ftype == TType.LIST:
7797 
          self.statuses = []
4983 phani.kuma 7798 
          (_etype101, _size98) = iprot.readListBegin()
7799 
          for _i102 in xrange(_size98):
7800 
            _elem103 = iprot.readI32();
7801 
            self.statuses.append(_elem103)
4133 chandransh 7802 
          iprot.readListEnd()
7803 
        else:
7804 
          iprot.skip(ftype)
7805 
      elif fid == 2:
7806 
        if ftype == TType.I64:
7807 
          self.warehouseId = iprot.readI64();
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
7819 
    oprot.writeStructBegin('getOrderCount_args')
7820 
    if self.statuses is not None:
7821 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7822 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4983 phani.kuma 7823 
      for iter104 in self.statuses:
7824 
        oprot.writeI32(iter104)
4133 chandransh 7825 
      oprot.writeListEnd()
7826 
      oprot.writeFieldEnd()
7827 
    if self.warehouseId is not None:
7828 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7829 
      oprot.writeI64(self.warehouseId)
7830 
      oprot.writeFieldEnd()
7831 
    oprot.writeFieldStop()
7832 
    oprot.writeStructEnd()
7833 
 
7834 
  def validate(self):
7835 
    return
7836 
 
7837 
 
7838 
  def __repr__(self):
7839 
    L = ['%s=%r' % (key, value)
7840 
      for key, value in self.__dict__.iteritems()]
7841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7842 
 
7843 
  def __eq__(self, other):
7844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7845 
 
7846 
  def __ne__(self, other):
7847 
    return not (self == other)
7848 
 
7849 
class getOrderCount_result:
7850 
  """
7851 
  Attributes:
7852 
   - success
7853 
   - ex
7854 
  """
7855 
 
7856 
  thrift_spec = (
7857 
    (0, TType.I32, 'success', None, None, ), # 0
7858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7859 
  )
7860 
 
7861 
  def __init__(self, success=None, ex=None,):
7862 
    self.success = success
7863 
    self.ex = ex
7864 
 
7865 
  def read(self, iprot):
7866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7868 
      return
7869 
    iprot.readStructBegin()
7870 
    while True:
7871 
      (fname, ftype, fid) = iprot.readFieldBegin()
7872 
      if ftype == TType.STOP:
7873 
        break
7874 
      if fid == 0:
7875 
        if ftype == TType.I32:
7876 
          self.success = iprot.readI32();
7877 
        else:
7878 
          iprot.skip(ftype)
7879 
      elif fid == 1:
7880 
        if ftype == TType.STRUCT:
7881 
          self.ex = TransactionServiceException()
7882 
          self.ex.read(iprot)
7883 
        else:
7884 
          iprot.skip(ftype)
7885 
      else:
7886 
        iprot.skip(ftype)
7887 
      iprot.readFieldEnd()
7888 
    iprot.readStructEnd()
7889 
 
7890 
  def write(self, oprot):
7891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7893 
      return
7894 
    oprot.writeStructBegin('getOrderCount_result')
7895 
    if self.success is not None:
7896 
      oprot.writeFieldBegin('success', TType.I32, 0)
7897 
      oprot.writeI32(self.success)
7898 
      oprot.writeFieldEnd()
7899 
    if self.ex is not None:
7900 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7901 
      self.ex.write(oprot)
7902 
      oprot.writeFieldEnd()
7903 
    oprot.writeFieldStop()
7904 
    oprot.writeStructEnd()
7905 
 
7906 
  def validate(self):
7907 
    return
7908 
 
7909 
 
7910 
  def __repr__(self):
7911 
    L = ['%s=%r' % (key, value)
7912 
      for key, value in self.__dict__.iteritems()]
7913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7914 
 
7915 
  def __eq__(self, other):
7916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7917 
 
7918 
  def __ne__(self, other):
7919 
    return not (self == other)
7920 
 
999 varun.gupt 7921 
class getOrdersByBillingDate_args:
7922 
  """
7923 
  Attributes:
7924 
   - status
7925 
   - start_billing_date
7926 
   - end_billing_date
7927 
   - warehouse_id
7928 
  """
7929 
 
7930 
  thrift_spec = (
7931 
    None, # 0
7932 
    (1, TType.I32, 'status', None, None, ), # 1
7933 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7934 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7935 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7936 
  )
7937 
 
7938 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7939 
    self.status = status
7940 
    self.start_billing_date = start_billing_date
7941 
    self.end_billing_date = end_billing_date
7942 
    self.warehouse_id = warehouse_id
7943 
 
7944 
  def read(self, iprot):
7945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7947 
      return
7948 
    iprot.readStructBegin()
7949 
    while True:
7950 
      (fname, ftype, fid) = iprot.readFieldBegin()
7951 
      if ftype == TType.STOP:
7952 
        break
7953 
      if fid == 1:
7954 
        if ftype == TType.I32:
7955 
          self.status = iprot.readI32();
7956 
        else:
7957 
          iprot.skip(ftype)
7958 
      elif fid == 2:
7959 
        if ftype == TType.I64:
7960 
          self.start_billing_date = iprot.readI64();
7961 
        else:
7962 
          iprot.skip(ftype)
7963 
      elif fid == 3:
7964 
        if ftype == TType.I64:
7965 
          self.end_billing_date = iprot.readI64();
7966 
        else:
7967 
          iprot.skip(ftype)
7968 
      elif fid == 4:
7969 
        if ftype == TType.I64:
7970 
          self.warehouse_id = iprot.readI64();
7971 
        else:
7972 
          iprot.skip(ftype)
7973 
      else:
7974 
        iprot.skip(ftype)
7975 
      iprot.readFieldEnd()
7976 
    iprot.readStructEnd()
7977 
 
7978 
  def write(self, oprot):
7979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7981 
      return
7982 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7983 
    if self.status is not None:
999 varun.gupt 7984 
      oprot.writeFieldBegin('status', TType.I32, 1)
7985 
      oprot.writeI32(self.status)
7986 
      oprot.writeFieldEnd()
3431 rajveer 7987 
    if self.start_billing_date is not None:
999 varun.gupt 7988 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7989 
      oprot.writeI64(self.start_billing_date)
7990 
      oprot.writeFieldEnd()
3431 rajveer 7991 
    if self.end_billing_date is not None:
999 varun.gupt 7992 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7993 
      oprot.writeI64(self.end_billing_date)
7994 
      oprot.writeFieldEnd()
3431 rajveer 7995 
    if self.warehouse_id is not None:
999 varun.gupt 7996 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7997 
      oprot.writeI64(self.warehouse_id)
7998 
      oprot.writeFieldEnd()
7999 
    oprot.writeFieldStop()
8000 
    oprot.writeStructEnd()
8001 
 
3431 rajveer 8002 
  def validate(self):
8003 
    return
8004 
 
8005 
 
999 varun.gupt 8006 
  def __repr__(self):
8007 
    L = ['%s=%r' % (key, value)
8008 
      for key, value in self.__dict__.iteritems()]
8009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8010 
 
8011 
  def __eq__(self, other):
8012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8013 
 
8014 
  def __ne__(self, other):
8015 
    return not (self == other)
8016 
 
8017 
class getOrdersByBillingDate_result:
8018 
  """
8019 
  Attributes:
8020 
   - success
8021 
   - ex
8022 
  """
8023 
 
8024 
  thrift_spec = (
8025 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8027 
  )
8028 
 
8029 
  def __init__(self, success=None, ex=None,):
8030 
    self.success = success
8031 
    self.ex = ex
8032 
 
8033 
  def read(self, iprot):
8034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8036 
      return
8037 
    iprot.readStructBegin()
8038 
    while True:
8039 
      (fname, ftype, fid) = iprot.readFieldBegin()
8040 
      if ftype == TType.STOP:
8041 
        break
8042 
      if fid == 0:
8043 
        if ftype == TType.LIST:
8044 
          self.success = []
4983 phani.kuma 8045 
          (_etype108, _size105) = iprot.readListBegin()
8046 
          for _i109 in xrange(_size105):
8047 
            _elem110 = Order()
8048 
            _elem110.read(iprot)
8049 
            self.success.append(_elem110)
999 varun.gupt 8050 
          iprot.readListEnd()
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      elif fid == 1:
8054 
        if ftype == TType.STRUCT:
8055 
          self.ex = TransactionServiceException()
8056 
          self.ex.read(iprot)
8057 
        else:
8058 
          iprot.skip(ftype)
8059 
      else:
8060 
        iprot.skip(ftype)
8061 
      iprot.readFieldEnd()
8062 
    iprot.readStructEnd()
8063 
 
8064 
  def write(self, oprot):
8065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8067 
      return
8068 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8069 
    if self.success is not None:
999 varun.gupt 8070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8071 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 8072 
      for iter111 in self.success:
8073 
        iter111.write(oprot)
999 varun.gupt 8074 
      oprot.writeListEnd()
8075 
      oprot.writeFieldEnd()
3431 rajveer 8076 
    if self.ex is not None:
999 varun.gupt 8077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8078 
      self.ex.write(oprot)
8079 
      oprot.writeFieldEnd()
8080 
    oprot.writeFieldStop()
8081 
    oprot.writeStructEnd()
8082 
 
3431 rajveer 8083 
  def validate(self):
8084 
    return
8085 
 
8086 
 
999 varun.gupt 8087 
  def __repr__(self):
8088 
    L = ['%s=%r' % (key, value)
8089 
      for key, value in self.__dict__.iteritems()]
8090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8091 
 
8092 
  def __eq__(self, other):
8093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8094 
 
8095 
  def __ne__(self, other):
8096 
    return not (self == other)
8097 
 
3427 chandransh 8098 
class getOrdersByShippingDate_args:
8099 
  """
8100 
  Attributes:
8101 
   - fromShippingDate
8102 
   - toShippingDate
8103 
   - providerId
8104 
   - warehouseId
3451 chandransh 8105 
   - cod
3427 chandransh 8106 
  """
8107 
 
8108 
  thrift_spec = (
8109 
    None, # 0
8110 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8111 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8112 
    (3, TType.I64, 'providerId', None, None, ), # 3
8113 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8114 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8115 
  )
8116 
 
3451 chandransh 8117 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8118 
    self.fromShippingDate = fromShippingDate
8119 
    self.toShippingDate = toShippingDate
8120 
    self.providerId = providerId
8121 
    self.warehouseId = warehouseId
3451 chandransh 8122 
    self.cod = cod
3427 chandransh 8123 
 
8124 
  def read(self, iprot):
8125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8127 
      return
8128 
    iprot.readStructBegin()
8129 
    while True:
8130 
      (fname, ftype, fid) = iprot.readFieldBegin()
8131 
      if ftype == TType.STOP:
8132 
        break
8133 
      if fid == 1:
8134 
        if ftype == TType.I64:
8135 
          self.fromShippingDate = iprot.readI64();
8136 
        else:
8137 
          iprot.skip(ftype)
8138 
      elif fid == 2:
8139 
        if ftype == TType.I64:
8140 
          self.toShippingDate = iprot.readI64();
8141 
        else:
8142 
          iprot.skip(ftype)
8143 
      elif fid == 3:
8144 
        if ftype == TType.I64:
8145 
          self.providerId = iprot.readI64();
8146 
        else:
8147 
          iprot.skip(ftype)
8148 
      elif fid == 4:
8149 
        if ftype == TType.I64:
8150 
          self.warehouseId = iprot.readI64();
8151 
        else:
8152 
          iprot.skip(ftype)
3451 chandransh 8153 
      elif fid == 5:
8154 
        if ftype == TType.BOOL:
8155 
          self.cod = iprot.readBool();
8156 
        else:
8157 
          iprot.skip(ftype)
3427 chandransh 8158 
      else:
8159 
        iprot.skip(ftype)
8160 
      iprot.readFieldEnd()
8161 
    iprot.readStructEnd()
8162 
 
8163 
  def write(self, oprot):
8164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8166 
      return
8167 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8168 
    if self.fromShippingDate is not None:
3427 chandransh 8169 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8170 
      oprot.writeI64(self.fromShippingDate)
8171 
      oprot.writeFieldEnd()
3431 rajveer 8172 
    if self.toShippingDate is not None:
3427 chandransh 8173 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8174 
      oprot.writeI64(self.toShippingDate)
8175 
      oprot.writeFieldEnd()
3431 rajveer 8176 
    if self.providerId is not None:
3427 chandransh 8177 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8178 
      oprot.writeI64(self.providerId)
8179 
      oprot.writeFieldEnd()
3431 rajveer 8180 
    if self.warehouseId is not None:
3427 chandransh 8181 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8182 
      oprot.writeI64(self.warehouseId)
8183 
      oprot.writeFieldEnd()
3451 chandransh 8184 
    if self.cod is not None:
8185 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8186 
      oprot.writeBool(self.cod)
8187 
      oprot.writeFieldEnd()
3427 chandransh 8188 
    oprot.writeFieldStop()
8189 
    oprot.writeStructEnd()
8190 
 
3431 rajveer 8191 
  def validate(self):
8192 
    return
8193 
 
8194 
 
3427 chandransh 8195 
  def __repr__(self):
8196 
    L = ['%s=%r' % (key, value)
8197 
      for key, value in self.__dict__.iteritems()]
8198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8199 
 
8200 
  def __eq__(self, other):
8201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8202 
 
8203 
  def __ne__(self, other):
8204 
    return not (self == other)
8205 
 
8206 
class getOrdersByShippingDate_result:
8207 
  """
8208 
  Attributes:
8209 
   - success
8210 
   - ex
8211 
  """
8212 
 
8213 
  thrift_spec = (
8214 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8216 
  )
8217 
 
8218 
  def __init__(self, success=None, ex=None,):
8219 
    self.success = success
8220 
    self.ex = ex
8221 
 
8222 
  def read(self, iprot):
8223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8225 
      return
8226 
    iprot.readStructBegin()
8227 
    while True:
8228 
      (fname, ftype, fid) = iprot.readFieldBegin()
8229 
      if ftype == TType.STOP:
8230 
        break
8231 
      if fid == 0:
8232 
        if ftype == TType.LIST:
8233 
          self.success = []
4983 phani.kuma 8234 
          (_etype115, _size112) = iprot.readListBegin()
8235 
          for _i116 in xrange(_size112):
8236 
            _elem117 = Order()
8237 
            _elem117.read(iprot)
8238 
            self.success.append(_elem117)
3427 chandransh 8239 
          iprot.readListEnd()
8240 
        else:
8241 
          iprot.skip(ftype)
8242 
      elif fid == 1:
8243 
        if ftype == TType.STRUCT:
8244 
          self.ex = TransactionServiceException()
8245 
          self.ex.read(iprot)
8246 
        else:
8247 
          iprot.skip(ftype)
8248 
      else:
8249 
        iprot.skip(ftype)
8250 
      iprot.readFieldEnd()
8251 
    iprot.readStructEnd()
8252 
 
8253 
  def write(self, oprot):
8254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8256 
      return
8257 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8258 
    if self.success is not None:
3427 chandransh 8259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 8261 
      for iter118 in self.success:
8262 
        iter118.write(oprot)
3427 chandransh 8263 
      oprot.writeListEnd()
8264 
      oprot.writeFieldEnd()
3431 rajveer 8265 
    if self.ex is not None:
3427 chandransh 8266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8267 
      self.ex.write(oprot)
8268 
      oprot.writeFieldEnd()
8269 
    oprot.writeFieldStop()
8270 
    oprot.writeStructEnd()
8271 
 
3431 rajveer 8272 
  def validate(self):
8273 
    return
8274 
 
8275 
 
3427 chandransh 8276 
  def __repr__(self):
8277 
    L = ['%s=%r' % (key, value)
8278 
      for key, value in self.__dict__.iteritems()]
8279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8280 
 
8281 
  def __eq__(self, other):
8282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8283 
 
8284 
  def __ne__(self, other):
8285 
    return not (self == other)
8286 
 
1382 varun.gupt 8287 
class getReturnableOrdersForCustomer_args:
8288 
  """
8289 
  Attributes:
8290 
   - customer_id
8291 
   - limit
8292 
  """
8293 
 
8294 
  thrift_spec = (
8295 
    None, # 0
8296 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8297 
    (2, TType.I64, 'limit', None, None, ), # 2
8298 
  )
8299 
 
8300 
  def __init__(self, customer_id=None, limit=None,):
8301 
    self.customer_id = customer_id
8302 
    self.limit = limit
8303 
 
8304 
  def read(self, iprot):
8305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8307 
      return
8308 
    iprot.readStructBegin()
8309 
    while True:
8310 
      (fname, ftype, fid) = iprot.readFieldBegin()
8311 
      if ftype == TType.STOP:
8312 
        break
8313 
      if fid == 1:
8314 
        if ftype == TType.I64:
8315 
          self.customer_id = iprot.readI64();
8316 
        else:
8317 
          iprot.skip(ftype)
8318 
      elif fid == 2:
8319 
        if ftype == TType.I64:
8320 
          self.limit = iprot.readI64();
8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      else:
8324 
        iprot.skip(ftype)
8325 
      iprot.readFieldEnd()
8326 
    iprot.readStructEnd()
8327 
 
8328 
  def write(self, oprot):
8329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8331 
      return
8332 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8333 
    if self.customer_id is not None:
1382 varun.gupt 8334 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8335 
      oprot.writeI64(self.customer_id)
8336 
      oprot.writeFieldEnd()
3431 rajveer 8337 
    if self.limit is not None:
1382 varun.gupt 8338 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8339 
      oprot.writeI64(self.limit)
8340 
      oprot.writeFieldEnd()
8341 
    oprot.writeFieldStop()
8342 
    oprot.writeStructEnd()
8343 
 
3431 rajveer 8344 
  def validate(self):
8345 
    return
8346 
 
8347 
 
1382 varun.gupt 8348 
  def __repr__(self):
8349 
    L = ['%s=%r' % (key, value)
8350 
      for key, value in self.__dict__.iteritems()]
8351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8352 
 
8353 
  def __eq__(self, other):
8354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8355 
 
8356 
  def __ne__(self, other):
8357 
    return not (self == other)
8358 
 
8359 
class getReturnableOrdersForCustomer_result:
8360 
  """
8361 
  Attributes:
8362 
   - success
8363 
   - ex
8364 
  """
8365 
 
8366 
  thrift_spec = (
8367 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8369 
  )
8370 
 
8371 
  def __init__(self, success=None, ex=None,):
8372 
    self.success = success
8373 
    self.ex = ex
8374 
 
8375 
  def read(self, iprot):
8376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8378 
      return
8379 
    iprot.readStructBegin()
8380 
    while True:
8381 
      (fname, ftype, fid) = iprot.readFieldBegin()
8382 
      if ftype == TType.STOP:
8383 
        break
8384 
      if fid == 0:
8385 
        if ftype == TType.LIST:
8386 
          self.success = []
4983 phani.kuma 8387 
          (_etype122, _size119) = iprot.readListBegin()
8388 
          for _i123 in xrange(_size119):
8389 
            _elem124 = iprot.readI64();
8390 
            self.success.append(_elem124)
1382 varun.gupt 8391 
          iprot.readListEnd()
8392 
        else:
8393 
          iprot.skip(ftype)
8394 
      elif fid == 1:
8395 
        if ftype == TType.STRUCT:
8396 
          self.ex = TransactionServiceException()
8397 
          self.ex.read(iprot)
8398 
        else:
8399 
          iprot.skip(ftype)
8400 
      else:
8401 
        iprot.skip(ftype)
8402 
      iprot.readFieldEnd()
8403 
    iprot.readStructEnd()
8404 
 
8405 
  def write(self, oprot):
8406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8408 
      return
8409 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8410 
    if self.success is not None:
1382 varun.gupt 8411 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8412 
      oprot.writeListBegin(TType.I64, len(self.success))
4983 phani.kuma 8413 
      for iter125 in self.success:
8414 
        oprot.writeI64(iter125)
1382 varun.gupt 8415 
      oprot.writeListEnd()
8416 
      oprot.writeFieldEnd()
3431 rajveer 8417 
    if self.ex is not None:
1382 varun.gupt 8418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8419 
      self.ex.write(oprot)
8420 
      oprot.writeFieldEnd()
8421 
    oprot.writeFieldStop()
8422 
    oprot.writeStructEnd()
8423 
 
3431 rajveer 8424 
  def validate(self):
8425 
    return
8426 
 
8427 
 
1382 varun.gupt 8428 
  def __repr__(self):
8429 
    L = ['%s=%r' % (key, value)
8430 
      for key, value in self.__dict__.iteritems()]
8431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8432 
 
8433 
  def __eq__(self, other):
8434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8435 
 
8436 
  def __ne__(self, other):
8437 
    return not (self == other)
8438 
 
8439 
class getCancellableOrdersForCustomer_args:
8440 
  """
8441 
  Attributes:
8442 
   - customer_id
8443 
   - limit
8444 
  """
8445 
 
8446 
  thrift_spec = (
8447 
    None, # 0
8448 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8449 
    (2, TType.I64, 'limit', None, None, ), # 2
8450 
  )
8451 
 
8452 
  def __init__(self, customer_id=None, limit=None,):
8453 
    self.customer_id = customer_id
8454 
    self.limit = limit
8455 
 
8456 
  def read(self, iprot):
8457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8459 
      return
8460 
    iprot.readStructBegin()
8461 
    while True:
8462 
      (fname, ftype, fid) = iprot.readFieldBegin()
8463 
      if ftype == TType.STOP:
8464 
        break
8465 
      if fid == 1:
8466 
        if ftype == TType.I64:
8467 
          self.customer_id = iprot.readI64();
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      elif fid == 2:
8471 
        if ftype == TType.I64:
8472 
          self.limit = iprot.readI64();
8473 
        else:
8474 
          iprot.skip(ftype)
8475 
      else:
8476 
        iprot.skip(ftype)
8477 
      iprot.readFieldEnd()
8478 
    iprot.readStructEnd()
8479 
 
8480 
  def write(self, oprot):
8481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8483 
      return
8484 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8485 
    if self.customer_id is not None:
1382 varun.gupt 8486 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8487 
      oprot.writeI64(self.customer_id)
8488 
      oprot.writeFieldEnd()
3431 rajveer 8489 
    if self.limit is not None:
1382 varun.gupt 8490 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8491 
      oprot.writeI64(self.limit)
8492 
      oprot.writeFieldEnd()
8493 
    oprot.writeFieldStop()
8494 
    oprot.writeStructEnd()
8495 
 
3431 rajveer 8496 
  def validate(self):
8497 
    return
8498 
 
8499 
 
1382 varun.gupt 8500 
  def __repr__(self):
8501 
    L = ['%s=%r' % (key, value)
8502 
      for key, value in self.__dict__.iteritems()]
8503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8504 
 
8505 
  def __eq__(self, other):
8506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8507 
 
8508 
  def __ne__(self, other):
8509 
    return not (self == other)
8510 
 
8511 
class getCancellableOrdersForCustomer_result:
8512 
  """
8513 
  Attributes:
8514 
   - success
8515 
   - ex
8516 
  """
8517 
 
8518 
  thrift_spec = (
8519 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8520 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8521 
  )
8522 
 
8523 
  def __init__(self, success=None, ex=None,):
8524 
    self.success = success
8525 
    self.ex = ex
8526 
 
8527 
  def read(self, iprot):
8528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8530 
      return
8531 
    iprot.readStructBegin()
8532 
    while True:
8533 
      (fname, ftype, fid) = iprot.readFieldBegin()
8534 
      if ftype == TType.STOP:
8535 
        break
8536 
      if fid == 0:
8537 
        if ftype == TType.LIST:
8538 
          self.success = []
4983 phani.kuma 8539 
          (_etype129, _size126) = iprot.readListBegin()
8540 
          for _i130 in xrange(_size126):
8541 
            _elem131 = iprot.readI64();
8542 
            self.success.append(_elem131)
1382 varun.gupt 8543 
          iprot.readListEnd()
8544 
        else:
8545 
          iprot.skip(ftype)
8546 
      elif fid == 1:
8547 
        if ftype == TType.STRUCT:
8548 
          self.ex = TransactionServiceException()
8549 
          self.ex.read(iprot)
8550 
        else:
8551 
          iprot.skip(ftype)
8552 
      else:
8553 
        iprot.skip(ftype)
8554 
      iprot.readFieldEnd()
8555 
    iprot.readStructEnd()
8556 
 
8557 
  def write(self, oprot):
8558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8560 
      return
8561 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8562 
    if self.success is not None:
1382 varun.gupt 8563 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8564 
      oprot.writeListBegin(TType.I64, len(self.success))
4983 phani.kuma 8565 
      for iter132 in self.success:
8566 
        oprot.writeI64(iter132)
1382 varun.gupt 8567 
      oprot.writeListEnd()
8568 
      oprot.writeFieldEnd()
3431 rajveer 8569 
    if self.ex is not None:
1382 varun.gupt 8570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8571 
      self.ex.write(oprot)
8572 
      oprot.writeFieldEnd()
8573 
    oprot.writeFieldStop()
8574 
    oprot.writeStructEnd()
8575 
 
3431 rajveer 8576 
  def validate(self):
8577 
    return
8578 
 
8579 
 
1382 varun.gupt 8580 
  def __repr__(self):
8581 
    L = ['%s=%r' % (key, value)
8582 
      for key, value in self.__dict__.iteritems()]
8583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8584 
 
8585 
  def __eq__(self, other):
8586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8587 
 
8588 
  def __ne__(self, other):
8589 
    return not (self == other)
8590 
 
483 rajveer 8591 
class changeOrderStatus_args:
94 ashish 8592 
  """
8593 
  Attributes:
483 rajveer 8594 
   - orderId
8595 
   - status
8596 
   - description
94 ashish 8597 
  """
8598 
 
8599 
  thrift_spec = (
8600 
    None, # 0
483 rajveer 8601 
    (1, TType.I64, 'orderId', None, None, ), # 1
8602 
    (2, TType.I32, 'status', None, None, ), # 2
8603 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8604 
  )
8605 
 
483 rajveer 8606 
  def __init__(self, orderId=None, status=None, description=None,):
8607 
    self.orderId = orderId
8608 
    self.status = status
8609 
    self.description = description
94 ashish 8610 
 
8611 
  def read(self, iprot):
8612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8614 
      return
8615 
    iprot.readStructBegin()
8616 
    while True:
8617 
      (fname, ftype, fid) = iprot.readFieldBegin()
8618 
      if ftype == TType.STOP:
8619 
        break
8620 
      if fid == 1:
8621 
        if ftype == TType.I64:
483 rajveer 8622 
          self.orderId = iprot.readI64();
94 ashish 8623 
        else:
8624 
          iprot.skip(ftype)
8625 
      elif fid == 2:
483 rajveer 8626 
        if ftype == TType.I32:
8627 
          self.status = iprot.readI32();
94 ashish 8628 
        else:
8629 
          iprot.skip(ftype)
483 rajveer 8630 
      elif fid == 3:
8631 
        if ftype == TType.STRING:
8632 
          self.description = iprot.readString();
8633 
        else:
8634 
          iprot.skip(ftype)
94 ashish 8635 
      else:
8636 
        iprot.skip(ftype)
8637 
      iprot.readFieldEnd()
8638 
    iprot.readStructEnd()
8639 
 
8640 
  def write(self, oprot):
8641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8643 
      return
483 rajveer 8644 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8645 
    if self.orderId is not None:
483 rajveer 8646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8647 
      oprot.writeI64(self.orderId)
94 ashish 8648 
      oprot.writeFieldEnd()
3431 rajveer 8649 
    if self.status is not None:
483 rajveer 8650 
      oprot.writeFieldBegin('status', TType.I32, 2)
8651 
      oprot.writeI32(self.status)
94 ashish 8652 
      oprot.writeFieldEnd()
3431 rajveer 8653 
    if self.description is not None:
483 rajveer 8654 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8655 
      oprot.writeString(self.description)
8656 
      oprot.writeFieldEnd()
94 ashish 8657 
    oprot.writeFieldStop()
8658 
    oprot.writeStructEnd()
8659 
 
3431 rajveer 8660 
  def validate(self):
8661 
    return
8662 
 
8663 
 
94 ashish 8664 
  def __repr__(self):
8665 
    L = ['%s=%r' % (key, value)
8666 
      for key, value in self.__dict__.iteritems()]
8667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8668 
 
8669 
  def __eq__(self, other):
8670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8671 
 
8672 
  def __ne__(self, other):
8673 
    return not (self == other)
8674 
 
483 rajveer 8675 
class changeOrderStatus_result:
94 ashish 8676 
  """
8677 
  Attributes:
8678 
   - success
8679 
   - ex
8680 
  """
8681 
 
8682 
  thrift_spec = (
8683 
    (0, TType.BOOL, 'success', None, None, ), # 0
8684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8685 
  )
8686 
 
8687 
  def __init__(self, success=None, ex=None,):
8688 
    self.success = success
8689 
    self.ex = ex
8690 
 
8691 
  def read(self, iprot):
8692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8694 
      return
8695 
    iprot.readStructBegin()
8696 
    while True:
8697 
      (fname, ftype, fid) = iprot.readFieldBegin()
8698 
      if ftype == TType.STOP:
8699 
        break
8700 
      if fid == 0:
8701 
        if ftype == TType.BOOL:
8702 
          self.success = iprot.readBool();
8703 
        else:
8704 
          iprot.skip(ftype)
8705 
      elif fid == 1:
8706 
        if ftype == TType.STRUCT:
8707 
          self.ex = TransactionServiceException()
8708 
          self.ex.read(iprot)
8709 
        else:
8710 
          iprot.skip(ftype)
8711 
      else:
8712 
        iprot.skip(ftype)
8713 
      iprot.readFieldEnd()
8714 
    iprot.readStructEnd()
8715 
 
8716 
  def write(self, oprot):
8717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8719 
      return
483 rajveer 8720 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8721 
    if self.success is not None:
94 ashish 8722 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8723 
      oprot.writeBool(self.success)
8724 
      oprot.writeFieldEnd()
3431 rajveer 8725 
    if self.ex is not None:
94 ashish 8726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8727 
      self.ex.write(oprot)
8728 
      oprot.writeFieldEnd()
8729 
    oprot.writeFieldStop()
8730 
    oprot.writeStructEnd()
8731 
 
3431 rajveer 8732 
  def validate(self):
8733 
    return
8734 
 
8735 
 
94 ashish 8736 
  def __repr__(self):
8737 
    L = ['%s=%r' % (key, value)
8738 
      for key, value in self.__dict__.iteritems()]
8739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8740 
 
8741 
  def __eq__(self, other):
8742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8743 
 
8744 
  def __ne__(self, other):
8745 
    return not (self == other)
8746 
 
3064 chandransh 8747 
class getOrdersForTransaction_args:
494 rajveer 8748 
  """
8749 
  Attributes:
3064 chandransh 8750 
   - transactionId
8751 
   - customerId
494 rajveer 8752 
  """
8753 
 
8754 
  thrift_spec = (
8755 
    None, # 0
3064 chandransh 8756 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8757 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8758 
  )
8759 
 
3064 chandransh 8760 
  def __init__(self, transactionId=None, customerId=None,):
8761 
    self.transactionId = transactionId
8762 
    self.customerId = customerId
494 rajveer 8763 
 
8764 
  def read(self, iprot):
8765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8767 
      return
8768 
    iprot.readStructBegin()
8769 
    while True:
8770 
      (fname, ftype, fid) = iprot.readFieldBegin()
8771 
      if ftype == TType.STOP:
8772 
        break
8773 
      if fid == 1:
8774 
        if ftype == TType.I64:
3064 chandransh 8775 
          self.transactionId = iprot.readI64();
494 rajveer 8776 
        else:
8777 
          iprot.skip(ftype)
8778 
      elif fid == 2:
3064 chandransh 8779 
        if ftype == TType.I64:
8780 
          self.customerId = iprot.readI64();
494 rajveer 8781 
        else:
8782 
          iprot.skip(ftype)
8783 
      else:
8784 
        iprot.skip(ftype)
8785 
      iprot.readFieldEnd()
8786 
    iprot.readStructEnd()
8787 
 
8788 
  def write(self, oprot):
8789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8791 
      return
3064 chandransh 8792 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8793 
    if self.transactionId is not None:
3064 chandransh 8794 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8795 
      oprot.writeI64(self.transactionId)
494 rajveer 8796 
      oprot.writeFieldEnd()
3431 rajveer 8797 
    if self.customerId is not None:
3064 chandransh 8798 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8799 
      oprot.writeI64(self.customerId)
494 rajveer 8800 
      oprot.writeFieldEnd()
8801 
    oprot.writeFieldStop()
8802 
    oprot.writeStructEnd()
8803 
 
3431 rajveer 8804 
  def validate(self):
8805 
    return
8806 
 
8807 
 
494 rajveer 8808 
  def __repr__(self):
8809 
    L = ['%s=%r' % (key, value)
8810 
      for key, value in self.__dict__.iteritems()]
8811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8812 
 
8813 
  def __eq__(self, other):
8814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8815 
 
8816 
  def __ne__(self, other):
8817 
    return not (self == other)
8818 
 
3064 chandransh 8819 
class getOrdersForTransaction_result:
494 rajveer 8820 
  """
8821 
  Attributes:
8822 
   - success
8823 
   - ex
8824 
  """
8825 
 
8826 
  thrift_spec = (
3064 chandransh 8827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8829 
  )
8830 
 
8831 
  def __init__(self, success=None, ex=None,):
8832 
    self.success = success
8833 
    self.ex = ex
8834 
 
8835 
  def read(self, iprot):
8836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8838 
      return
8839 
    iprot.readStructBegin()
8840 
    while True:
8841 
      (fname, ftype, fid) = iprot.readFieldBegin()
8842 
      if ftype == TType.STOP:
8843 
        break
8844 
      if fid == 0:
3064 chandransh 8845 
        if ftype == TType.LIST:
8846 
          self.success = []
4983 phani.kuma 8847 
          (_etype136, _size133) = iprot.readListBegin()
8848 
          for _i137 in xrange(_size133):
8849 
            _elem138 = Order()
8850 
            _elem138.read(iprot)
8851 
            self.success.append(_elem138)
3064 chandransh 8852 
          iprot.readListEnd()
494 rajveer 8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      elif fid == 1:
8856 
        if ftype == TType.STRUCT:
8857 
          self.ex = TransactionServiceException()
8858 
          self.ex.read(iprot)
8859 
        else:
8860 
          iprot.skip(ftype)
8861 
      else:
8862 
        iprot.skip(ftype)
8863 
      iprot.readFieldEnd()
8864 
    iprot.readStructEnd()
8865 
 
8866 
  def write(self, oprot):
8867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8869 
      return
3064 chandransh 8870 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8871 
    if self.success is not None:
3064 chandransh 8872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 8874 
      for iter139 in self.success:
8875 
        iter139.write(oprot)
3064 chandransh 8876 
      oprot.writeListEnd()
494 rajveer 8877 
      oprot.writeFieldEnd()
3431 rajveer 8878 
    if self.ex is not None:
494 rajveer 8879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8880 
      self.ex.write(oprot)
8881 
      oprot.writeFieldEnd()
8882 
    oprot.writeFieldStop()
8883 
    oprot.writeStructEnd()
8884 
 
3431 rajveer 8885 
  def validate(self):
8886 
    return
8887 
 
8888 
 
494 rajveer 8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
3064 chandransh 8900 
class getOrdersForCustomer_args:
1149 chandransh 8901 
  """
8902 
  Attributes:
3064 chandransh 8903 
   - customerId
8904 
   - from_date
8905 
   - to_date
8906 
   - statuses
1149 chandransh 8907 
  """
8908 
 
8909 
  thrift_spec = (
8910 
    None, # 0
3064 chandransh 8911 
    (1, TType.I64, 'customerId', None, None, ), # 1
8912 
    (2, TType.I64, 'from_date', None, None, ), # 2
8913 
    (3, TType.I64, 'to_date', None, None, ), # 3
8914 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8915 
  )
8916 
 
3064 chandransh 8917 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8918 
    self.customerId = customerId
8919 
    self.from_date = from_date
8920 
    self.to_date = to_date
8921 
    self.statuses = statuses
1149 chandransh 8922 
 
8923 
  def read(self, iprot):
8924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8926 
      return
8927 
    iprot.readStructBegin()
8928 
    while True:
8929 
      (fname, ftype, fid) = iprot.readFieldBegin()
8930 
      if ftype == TType.STOP:
8931 
        break
8932 
      if fid == 1:
8933 
        if ftype == TType.I64:
3064 chandransh 8934 
          self.customerId = iprot.readI64();
1149 chandransh 8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      elif fid == 2:
8938 
        if ftype == TType.I64:
3064 chandransh 8939 
          self.from_date = iprot.readI64();
1149 chandransh 8940 
        else:
8941 
          iprot.skip(ftype)
2783 chandransh 8942 
      elif fid == 3:
8943 
        if ftype == TType.I64:
3064 chandransh 8944 
          self.to_date = iprot.readI64();
2783 chandransh 8945 
        else:
8946 
          iprot.skip(ftype)
8947 
      elif fid == 4:
3064 chandransh 8948 
        if ftype == TType.LIST:
8949 
          self.statuses = []
4983 phani.kuma 8950 
          (_etype143, _size140) = iprot.readListBegin()
8951 
          for _i144 in xrange(_size140):
8952 
            _elem145 = iprot.readI32();
8953 
            self.statuses.append(_elem145)
3064 chandransh 8954 
          iprot.readListEnd()
2783 chandransh 8955 
        else:
8956 
          iprot.skip(ftype)
1149 chandransh 8957 
      else:
8958 
        iprot.skip(ftype)
8959 
      iprot.readFieldEnd()
8960 
    iprot.readStructEnd()
8961 
 
8962 
  def write(self, oprot):
8963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8965 
      return
3064 chandransh 8966 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8967 
    if self.customerId is not None:
3064 chandransh 8968 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8969 
      oprot.writeI64(self.customerId)
1149 chandransh 8970 
      oprot.writeFieldEnd()
3431 rajveer 8971 
    if self.from_date is not None:
3064 chandransh 8972 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8973 
      oprot.writeI64(self.from_date)
1149 chandransh 8974 
      oprot.writeFieldEnd()
3431 rajveer 8975 
    if self.to_date is not None:
3064 chandransh 8976 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8977 
      oprot.writeI64(self.to_date)
2783 chandransh 8978 
      oprot.writeFieldEnd()
3431 rajveer 8979 
    if self.statuses is not None:
3064 chandransh 8980 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8981 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4983 phani.kuma 8982 
      for iter146 in self.statuses:
8983 
        oprot.writeI32(iter146)
3064 chandransh 8984 
      oprot.writeListEnd()
2783 chandransh 8985 
      oprot.writeFieldEnd()
1149 chandransh 8986 
    oprot.writeFieldStop()
8987 
    oprot.writeStructEnd()
8988 
 
3431 rajveer 8989 
  def validate(self):
8990 
    return
8991 
 
8992 
 
1149 chandransh 8993 
  def __repr__(self):
8994 
    L = ['%s=%r' % (key, value)
8995 
      for key, value in self.__dict__.iteritems()]
8996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8997 
 
8998 
  def __eq__(self, other):
8999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9000 
 
9001 
  def __ne__(self, other):
9002 
    return not (self == other)
9003 
 
3064 chandransh 9004 
class getOrdersForCustomer_result:
1149 chandransh 9005 
  """
9006 
  Attributes:
9007 
   - success
9008 
   - ex
9009 
  """
9010 
 
9011 
  thrift_spec = (
3064 chandransh 9012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9014 
  )
9015 
 
9016 
  def __init__(self, success=None, ex=None,):
9017 
    self.success = success
9018 
    self.ex = ex
9019 
 
9020 
  def read(self, iprot):
9021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9023 
      return
9024 
    iprot.readStructBegin()
9025 
    while True:
9026 
      (fname, ftype, fid) = iprot.readFieldBegin()
9027 
      if ftype == TType.STOP:
9028 
        break
9029 
      if fid == 0:
3064 chandransh 9030 
        if ftype == TType.LIST:
9031 
          self.success = []
4983 phani.kuma 9032 
          (_etype150, _size147) = iprot.readListBegin()
9033 
          for _i151 in xrange(_size147):
9034 
            _elem152 = Order()
9035 
            _elem152.read(iprot)
9036 
            self.success.append(_elem152)
3064 chandransh 9037 
          iprot.readListEnd()
1149 chandransh 9038 
        else:
9039 
          iprot.skip(ftype)
9040 
      elif fid == 1:
9041 
        if ftype == TType.STRUCT:
9042 
          self.ex = TransactionServiceException()
9043 
          self.ex.read(iprot)
9044 
        else:
9045 
          iprot.skip(ftype)
9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
3064 chandransh 9055 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9056 
    if self.success is not None:
3064 chandransh 9057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 9059 
      for iter153 in self.success:
9060 
        iter153.write(oprot)
3064 chandransh 9061 
      oprot.writeListEnd()
1149 chandransh 9062 
      oprot.writeFieldEnd()
3431 rajveer 9063 
    if self.ex is not None:
1149 chandransh 9064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9065 
      self.ex.write(oprot)
9066 
      oprot.writeFieldEnd()
9067 
    oprot.writeFieldStop()
9068 
    oprot.writeStructEnd()
9069 
 
3431 rajveer 9070 
  def validate(self):
9071 
    return
9072 
 
9073 
 
1149 chandransh 9074 
  def __repr__(self):
9075 
    L = ['%s=%r' % (key, value)
9076 
      for key, value in self.__dict__.iteritems()]
9077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9078 
 
9079 
  def __eq__(self, other):
9080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9081 
 
9082 
  def __ne__(self, other):
9083 
    return not (self == other)
9084 
 
3064 chandransh 9085 
class createOrder_args:
921 rajveer 9086 
  """
9087 
  Attributes:
3064 chandransh 9088 
   - order
921 rajveer 9089 
  """
9090 
 
9091 
  thrift_spec = (
9092 
    None, # 0
3064 chandransh 9093 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9094 
  )
9095 
 
3064 chandransh 9096 
  def __init__(self, order=None,):
9097 
    self.order = order
921 rajveer 9098 
 
9099 
  def read(self, iprot):
9100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9102 
      return
9103 
    iprot.readStructBegin()
9104 
    while True:
9105 
      (fname, ftype, fid) = iprot.readFieldBegin()
9106 
      if ftype == TType.STOP:
9107 
        break
9108 
      if fid == 1:
3064 chandransh 9109 
        if ftype == TType.STRUCT:
9110 
          self.order = Order()
9111 
          self.order.read(iprot)
921 rajveer 9112 
        else:
9113 
          iprot.skip(ftype)
9114 
      else:
9115 
        iprot.skip(ftype)
9116 
      iprot.readFieldEnd()
9117 
    iprot.readStructEnd()
9118 
 
9119 
  def write(self, oprot):
9120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9122 
      return
3064 chandransh 9123 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9124 
    if self.order is not None:
3064 chandransh 9125 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9126 
      self.order.write(oprot)
921 rajveer 9127 
      oprot.writeFieldEnd()
9128 
    oprot.writeFieldStop()
9129 
    oprot.writeStructEnd()
9130 
 
3431 rajveer 9131 
  def validate(self):
9132 
    return
9133 
 
9134 
 
921 rajveer 9135 
  def __repr__(self):
9136 
    L = ['%s=%r' % (key, value)
9137 
      for key, value in self.__dict__.iteritems()]
9138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9139 
 
9140 
  def __eq__(self, other):
9141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9142 
 
9143 
  def __ne__(self, other):
9144 
    return not (self == other)
9145 
 
3064 chandransh 9146 
class createOrder_result:
921 rajveer 9147 
  """
9148 
  Attributes:
9149 
   - success
9150 
   - ex
9151 
  """
9152 
 
9153 
  thrift_spec = (
3064 chandransh 9154 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9156 
  )
9157 
 
9158 
  def __init__(self, success=None, ex=None,):
9159 
    self.success = success
9160 
    self.ex = ex
9161 
 
9162 
  def read(self, iprot):
9163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9165 
      return
9166 
    iprot.readStructBegin()
9167 
    while True:
9168 
      (fname, ftype, fid) = iprot.readFieldBegin()
9169 
      if ftype == TType.STOP:
9170 
        break
9171 
      if fid == 0:
3064 chandransh 9172 
        if ftype == TType.I64:
9173 
          self.success = iprot.readI64();
921 rajveer 9174 
        else:
9175 
          iprot.skip(ftype)
9176 
      elif fid == 1:
9177 
        if ftype == TType.STRUCT:
9178 
          self.ex = TransactionServiceException()
9179 
          self.ex.read(iprot)
9180 
        else:
9181 
          iprot.skip(ftype)
9182 
      else:
9183 
        iprot.skip(ftype)
9184 
      iprot.readFieldEnd()
9185 
    iprot.readStructEnd()
9186 
 
9187 
  def write(self, oprot):
9188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9190 
      return
3064 chandransh 9191 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9192 
    if self.success is not None:
3064 chandransh 9193 
      oprot.writeFieldBegin('success', TType.I64, 0)
9194 
      oprot.writeI64(self.success)
921 rajveer 9195 
      oprot.writeFieldEnd()
3431 rajveer 9196 
    if self.ex is not None:
921 rajveer 9197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9198 
      self.ex.write(oprot)
9199 
      oprot.writeFieldEnd()
9200 
    oprot.writeFieldStop()
9201 
    oprot.writeStructEnd()
9202 
 
3431 rajveer 9203 
  def validate(self):
9204 
    return
9205 
 
9206 
 
921 rajveer 9207 
  def __repr__(self):
9208 
    L = ['%s=%r' % (key, value)
9209 
      for key, value in self.__dict__.iteritems()]
9210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9211 
 
9212 
  def __eq__(self, other):
9213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9214 
 
9215 
  def __ne__(self, other):
9216 
    return not (self == other)
9217 
 
3064 chandransh 9218 
class getOrder_args:
921 rajveer 9219 
  """
9220 
  Attributes:
3064 chandransh 9221 
   - id
921 rajveer 9222 
  """
9223 
 
9224 
  thrift_spec = (
9225 
    None, # 0
3064 chandransh 9226 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9227 
  )
9228 
 
3064 chandransh 9229 
  def __init__(self, id=None,):
9230 
    self.id = id
921 rajveer 9231 
 
9232 
  def read(self, iprot):
9233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9235 
      return
9236 
    iprot.readStructBegin()
9237 
    while True:
9238 
      (fname, ftype, fid) = iprot.readFieldBegin()
9239 
      if ftype == TType.STOP:
9240 
        break
9241 
      if fid == 1:
9242 
        if ftype == TType.I64:
3064 chandransh 9243 
          self.id = iprot.readI64();
921 rajveer 9244 
        else:
9245 
          iprot.skip(ftype)
9246 
      else:
9247 
        iprot.skip(ftype)
9248 
      iprot.readFieldEnd()
9249 
    iprot.readStructEnd()
9250 
 
9251 
  def write(self, oprot):
9252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9254 
      return
3064 chandransh 9255 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9256 
    if self.id is not None:
3064 chandransh 9257 
      oprot.writeFieldBegin('id', TType.I64, 1)
9258 
      oprot.writeI64(self.id)
921 rajveer 9259 
      oprot.writeFieldEnd()
9260 
    oprot.writeFieldStop()
9261 
    oprot.writeStructEnd()
9262 
 
3431 rajveer 9263 
  def validate(self):
9264 
    return
9265 
 
9266 
 
921 rajveer 9267 
  def __repr__(self):
9268 
    L = ['%s=%r' % (key, value)
9269 
      for key, value in self.__dict__.iteritems()]
9270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9271 
 
9272 
  def __eq__(self, other):
9273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9274 
 
9275 
  def __ne__(self, other):
9276 
    return not (self == other)
9277 
 
3064 chandransh 9278 
class getOrder_result:
921 rajveer 9279 
  """
9280 
  Attributes:
9281 
   - success
9282 
   - ex
9283 
  """
9284 
 
9285 
  thrift_spec = (
3064 chandransh 9286 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9288 
  )
9289 
 
9290 
  def __init__(self, success=None, ex=None,):
9291 
    self.success = success
9292 
    self.ex = ex
9293 
 
9294 
  def read(self, iprot):
9295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9297 
      return
9298 
    iprot.readStructBegin()
9299 
    while True:
9300 
      (fname, ftype, fid) = iprot.readFieldBegin()
9301 
      if ftype == TType.STOP:
9302 
        break
9303 
      if fid == 0:
3064 chandransh 9304 
        if ftype == TType.STRUCT:
9305 
          self.success = Order()
9306 
          self.success.read(iprot)
921 rajveer 9307 
        else:
9308 
          iprot.skip(ftype)
9309 
      elif fid == 1:
9310 
        if ftype == TType.STRUCT:
9311 
          self.ex = TransactionServiceException()
9312 
          self.ex.read(iprot)
9313 
        else:
9314 
          iprot.skip(ftype)
9315 
      else:
9316 
        iprot.skip(ftype)
9317 
      iprot.readFieldEnd()
9318 
    iprot.readStructEnd()
9319 
 
9320 
  def write(self, oprot):
9321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9323 
      return
3064 chandransh 9324 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9325 
    if self.success is not None:
3064 chandransh 9326 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9327 
      self.success.write(oprot)
921 rajveer 9328 
      oprot.writeFieldEnd()
3431 rajveer 9329 
    if self.ex is not None:
921 rajveer 9330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9331 
      self.ex.write(oprot)
9332 
      oprot.writeFieldEnd()
9333 
    oprot.writeFieldStop()
9334 
    oprot.writeStructEnd()
9335 
 
3431 rajveer 9336 
  def validate(self):
9337 
    return
9338 
 
9339 
 
921 rajveer 9340 
  def __repr__(self):
9341 
    L = ['%s=%r' % (key, value)
9342 
      for key, value in self.__dict__.iteritems()]
9343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9344 
 
9345 
  def __eq__(self, other):
9346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9347 
 
9348 
  def __ne__(self, other):
9349 
    return not (self == other)
9350 
 
3064 chandransh 9351 
class getLineItemsForOrder_args:
94 ashish 9352 
  """
9353 
  Attributes:
3064 chandransh 9354 
   - orderId
94 ashish 9355 
  """
9356 
 
9357 
  thrift_spec = (
9358 
    None, # 0
3064 chandransh 9359 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9360 
  )
9361 
 
3064 chandransh 9362 
  def __init__(self, orderId=None,):
9363 
    self.orderId = orderId
94 ashish 9364 
 
9365 
  def read(self, iprot):
9366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9368 
      return
9369 
    iprot.readStructBegin()
9370 
    while True:
9371 
      (fname, ftype, fid) = iprot.readFieldBegin()
9372 
      if ftype == TType.STOP:
9373 
        break
9374 
      if fid == 1:
9375 
        if ftype == TType.I64:
3064 chandransh 9376 
          self.orderId = iprot.readI64();
94 ashish 9377 
        else:
9378 
          iprot.skip(ftype)
9379 
      else:
9380 
        iprot.skip(ftype)
9381 
      iprot.readFieldEnd()
9382 
    iprot.readStructEnd()
9383 
 
9384 
  def write(self, oprot):
9385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9387 
      return
3064 chandransh 9388 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9389 
    if self.orderId is not None:
3064 chandransh 9390 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9391 
      oprot.writeI64(self.orderId)
94 ashish 9392 
      oprot.writeFieldEnd()
9393 
    oprot.writeFieldStop()
9394 
    oprot.writeStructEnd()
9395 
 
3431 rajveer 9396 
  def validate(self):
9397 
    return
9398 
 
9399 
 
94 ashish 9400 
  def __repr__(self):
9401 
    L = ['%s=%r' % (key, value)
9402 
      for key, value in self.__dict__.iteritems()]
9403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9404 
 
9405 
  def __eq__(self, other):
9406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9407 
 
9408 
  def __ne__(self, other):
9409 
    return not (self == other)
9410 
 
3064 chandransh 9411 
class getLineItemsForOrder_result:
94 ashish 9412 
  """
9413 
  Attributes:
9414 
   - success
9415 
   - ex
9416 
  """
9417 
 
9418 
  thrift_spec = (
3064 chandransh 9419 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9421 
  )
9422 
 
9423 
  def __init__(self, success=None, ex=None,):
9424 
    self.success = success
9425 
    self.ex = ex
9426 
 
9427 
  def read(self, iprot):
9428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9430 
      return
9431 
    iprot.readStructBegin()
9432 
    while True:
9433 
      (fname, ftype, fid) = iprot.readFieldBegin()
9434 
      if ftype == TType.STOP:
9435 
        break
9436 
      if fid == 0:
483 rajveer 9437 
        if ftype == TType.LIST:
9438 
          self.success = []
4983 phani.kuma 9439 
          (_etype157, _size154) = iprot.readListBegin()
9440 
          for _i158 in xrange(_size154):
9441 
            _elem159 = LineItem()
9442 
            _elem159.read(iprot)
9443 
            self.success.append(_elem159)
483 rajveer 9444 
          iprot.readListEnd()
94 ashish 9445 
        else:
9446 
          iprot.skip(ftype)
9447 
      elif fid == 1:
9448 
        if ftype == TType.STRUCT:
9449 
          self.ex = TransactionServiceException()
9450 
          self.ex.read(iprot)
9451 
        else:
9452 
          iprot.skip(ftype)
9453 
      else:
9454 
        iprot.skip(ftype)
9455 
      iprot.readFieldEnd()
9456 
    iprot.readStructEnd()
9457 
 
9458 
  def write(self, oprot):
9459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9461 
      return
3064 chandransh 9462 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9463 
    if self.success is not None:
483 rajveer 9464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4983 phani.kuma 9466 
      for iter160 in self.success:
9467 
        iter160.write(oprot)
483 rajveer 9468 
      oprot.writeListEnd()
94 ashish 9469 
      oprot.writeFieldEnd()
3431 rajveer 9470 
    if self.ex is not None:
94 ashish 9471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9472 
      self.ex.write(oprot)
9473 
      oprot.writeFieldEnd()
9474 
    oprot.writeFieldStop()
9475 
    oprot.writeStructEnd()
9476 
 
3431 rajveer 9477 
  def validate(self):
9478 
    return
9479 
 
9480 
 
94 ashish 9481 
  def __repr__(self):
9482 
    L = ['%s=%r' % (key, value)
9483 
      for key, value in self.__dict__.iteritems()]
9484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9485 
 
9486 
  def __eq__(self, other):
9487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9488 
 
9489 
  def __ne__(self, other):
9490 
    return not (self == other)
9491 
 
4999 phani.kuma 9492 
class getOrderList_args:
9493 
  """
9494 
  Attributes:
9495 
   - order_ids
9496 
  """
9497 
 
9498 
  thrift_spec = (
9499 
    None, # 0
9500 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9501 
  )
9502 
 
9503 
  def __init__(self, order_ids=None,):
9504 
    self.order_ids = order_ids
9505 
 
9506 
  def read(self, iprot):
9507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9509 
      return
9510 
    iprot.readStructBegin()
9511 
    while True:
9512 
      (fname, ftype, fid) = iprot.readFieldBegin()
9513 
      if ftype == TType.STOP:
9514 
        break
9515 
      if fid == 1:
9516 
        if ftype == TType.LIST:
9517 
          self.order_ids = []
9518 
          (_etype164, _size161) = iprot.readListBegin()
9519 
          for _i165 in xrange(_size161):
9520 
            _elem166 = iprot.readI64();
9521 
            self.order_ids.append(_elem166)
9522 
          iprot.readListEnd()
9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
9534 
    oprot.writeStructBegin('getOrderList_args')
9535 
    if self.order_ids is not None:
9536 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9537 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
9538 
      for iter167 in self.order_ids:
9539 
        oprot.writeI64(iter167)
9540 
      oprot.writeListEnd()
9541 
      oprot.writeFieldEnd()
9542 
    oprot.writeFieldStop()
9543 
    oprot.writeStructEnd()
9544 
 
9545 
  def validate(self):
9546 
    return
9547 
 
9548 
 
9549 
  def __repr__(self):
9550 
    L = ['%s=%r' % (key, value)
9551 
      for key, value in self.__dict__.iteritems()]
9552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9553 
 
9554 
  def __eq__(self, other):
9555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9556 
 
9557 
  def __ne__(self, other):
9558 
    return not (self == other)
9559 
 
9560 
class getOrderList_result:
9561 
  """
9562 
  Attributes:
9563 
   - success
9564 
  """
9565 
 
9566 
  thrift_spec = (
9567 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9568 
  )
9569 
 
9570 
  def __init__(self, success=None,):
9571 
    self.success = success
9572 
 
9573 
  def read(self, iprot):
9574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9576 
      return
9577 
    iprot.readStructBegin()
9578 
    while True:
9579 
      (fname, ftype, fid) = iprot.readFieldBegin()
9580 
      if ftype == TType.STOP:
9581 
        break
9582 
      if fid == 0:
9583 
        if ftype == TType.LIST:
9584 
          self.success = []
9585 
          (_etype171, _size168) = iprot.readListBegin()
9586 
          for _i172 in xrange(_size168):
9587 
            _elem173 = Order()
9588 
            _elem173.read(iprot)
9589 
            self.success.append(_elem173)
9590 
          iprot.readListEnd()
9591 
        else:
9592 
          iprot.skip(ftype)
9593 
      else:
9594 
        iprot.skip(ftype)
9595 
      iprot.readFieldEnd()
9596 
    iprot.readStructEnd()
9597 
 
9598 
  def write(self, oprot):
9599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9601 
      return
9602 
    oprot.writeStructBegin('getOrderList_result')
9603 
    if self.success is not None:
9604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9606 
      for iter174 in self.success:
9607 
        iter174.write(oprot)
9608 
      oprot.writeListEnd()
9609 
      oprot.writeFieldEnd()
9610 
    oprot.writeFieldStop()
9611 
    oprot.writeStructEnd()
9612 
 
9613 
  def validate(self):
9614 
    return
9615 
 
9616 
 
9617 
  def __repr__(self):
9618 
    L = ['%s=%r' % (key, value)
9619 
      for key, value in self.__dict__.iteritems()]
9620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9621 
 
9622 
  def __eq__(self, other):
9623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9624 
 
9625 
  def __ne__(self, other):
9626 
    return not (self == other)
9627 
 
3064 chandransh 9628 
class getOrderForCustomer_args:
94 ashish 9629 
  """
9630 
  Attributes:
3064 chandransh 9631 
   - orderId
483 rajveer 9632 
   - customerId
94 ashish 9633 
  """
9634 
 
9635 
  thrift_spec = (
9636 
    None, # 0
3064 chandransh 9637 
    (1, TType.I64, 'orderId', None, None, ), # 1
9638 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9639 
  )
9640 
 
3064 chandransh 9641 
  def __init__(self, orderId=None, customerId=None,):
9642 
    self.orderId = orderId
483 rajveer 9643 
    self.customerId = customerId
94 ashish 9644 
 
9645 
  def read(self, iprot):
9646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9648 
      return
9649 
    iprot.readStructBegin()
9650 
    while True:
9651 
      (fname, ftype, fid) = iprot.readFieldBegin()
9652 
      if ftype == TType.STOP:
9653 
        break
9654 
      if fid == 1:
9655 
        if ftype == TType.I64:
3064 chandransh 9656 
          self.orderId = iprot.readI64();
94 ashish 9657 
        else:
9658 
          iprot.skip(ftype)
9659 
      elif fid == 2:
9660 
        if ftype == TType.I64:
3064 chandransh 9661 
          self.customerId = iprot.readI64();
94 ashish 9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      else:
9665 
        iprot.skip(ftype)
9666 
      iprot.readFieldEnd()
9667 
    iprot.readStructEnd()
9668 
 
9669 
  def write(self, oprot):
9670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9672 
      return
3064 chandransh 9673 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9674 
    if self.orderId is not None:
3064 chandransh 9675 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9676 
      oprot.writeI64(self.orderId)
9677 
      oprot.writeFieldEnd()
3431 rajveer 9678 
    if self.customerId is not None:
3064 chandransh 9679 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9680 
      oprot.writeI64(self.customerId)
94 ashish 9681 
      oprot.writeFieldEnd()
9682 
    oprot.writeFieldStop()
9683 
    oprot.writeStructEnd()
9684 
 
3431 rajveer 9685 
  def validate(self):
9686 
    return
9687 
 
9688 
 
94 ashish 9689 
  def __repr__(self):
9690 
    L = ['%s=%r' % (key, value)
9691 
      for key, value in self.__dict__.iteritems()]
9692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9693 
 
9694 
  def __eq__(self, other):
9695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9696 
 
9697 
  def __ne__(self, other):
9698 
    return not (self == other)
9699 
 
3064 chandransh 9700 
class getOrderForCustomer_result:
94 ashish 9701 
  """
9702 
  Attributes:
9703 
   - success
9704 
   - ex
9705 
  """
9706 
 
9707 
  thrift_spec = (
3064 chandransh 9708 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9710 
  )
9711 
 
9712 
  def __init__(self, success=None, ex=None,):
9713 
    self.success = success
9714 
    self.ex = ex
9715 
 
9716 
  def read(self, iprot):
9717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9719 
      return
9720 
    iprot.readStructBegin()
9721 
    while True:
9722 
      (fname, ftype, fid) = iprot.readFieldBegin()
9723 
      if ftype == TType.STOP:
9724 
        break
9725 
      if fid == 0:
3064 chandransh 9726 
        if ftype == TType.STRUCT:
9727 
          self.success = Order()
9728 
          self.success.read(iprot)
94 ashish 9729 
        else:
9730 
          iprot.skip(ftype)
9731 
      elif fid == 1:
9732 
        if ftype == TType.STRUCT:
9733 
          self.ex = TransactionServiceException()
9734 
          self.ex.read(iprot)
9735 
        else:
9736 
          iprot.skip(ftype)
9737 
      else:
9738 
        iprot.skip(ftype)
9739 
      iprot.readFieldEnd()
9740 
    iprot.readStructEnd()
9741 
 
9742 
  def write(self, oprot):
9743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9745 
      return
3064 chandransh 9746 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9747 
    if self.success is not None:
3064 chandransh 9748 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9749 
      self.success.write(oprot)
94 ashish 9750 
      oprot.writeFieldEnd()
3431 rajveer 9751 
    if self.ex is not None:
94 ashish 9752 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9753 
      self.ex.write(oprot)
9754 
      oprot.writeFieldEnd()
9755 
    oprot.writeFieldStop()
9756 
    oprot.writeStructEnd()
9757 
 
3431 rajveer 9758 
  def validate(self):
9759 
    return
9760 
 
9761 
 
94 ashish 9762 
  def __repr__(self):
9763 
    L = ['%s=%r' % (key, value)
9764 
      for key, value in self.__dict__.iteritems()]
9765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9766 
 
9767 
  def __eq__(self, other):
9768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9769 
 
9770 
  def __ne__(self, other):
9771 
    return not (self == other)
9772 
 
3064 chandransh 9773 
class getAlerts_args:
94 ashish 9774 
  """
9775 
  Attributes:
4394 rajveer 9776 
   - type
4444 rajveer 9777 
   - warehouseId
4394 rajveer 9778 
   - status
9779 
   - timestamp
94 ashish 9780 
  """
9781 
 
9782 
  thrift_spec = (
9783 
    None, # 0
4394 rajveer 9784 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9785 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9786 
    (3, TType.I64, 'status', None, None, ), # 3
9787 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9788 
  )
9789 
 
4444 rajveer 9790 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9791 
    self.type = type
4444 rajveer 9792 
    self.warehouseId = warehouseId
4394 rajveer 9793 
    self.status = status
9794 
    self.timestamp = timestamp
94 ashish 9795 
 
9796 
  def read(self, iprot):
9797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9799 
      return
9800 
    iprot.readStructBegin()
9801 
    while True:
9802 
      (fname, ftype, fid) = iprot.readFieldBegin()
9803 
      if ftype == TType.STOP:
9804 
        break
9805 
      if fid == 1:
3064 chandransh 9806 
        if ftype == TType.I64:
4394 rajveer 9807 
          self.type = iprot.readI64();
94 ashish 9808 
        else:
9809 
          iprot.skip(ftype)
3064 chandransh 9810 
      elif fid == 2:
4394 rajveer 9811 
        if ftype == TType.I64:
4444 rajveer 9812 
          self.warehouseId = iprot.readI64();
3064 chandransh 9813 
        else:
9814 
          iprot.skip(ftype)
4394 rajveer 9815 
      elif fid == 3:
9816 
        if ftype == TType.I64:
4444 rajveer 9817 
          self.status = iprot.readI64();
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      elif fid == 4:
9821 
        if ftype == TType.I64:
4394 rajveer 9822 
          self.timestamp = iprot.readI64();
9823 
        else:
9824 
          iprot.skip(ftype)
94 ashish 9825 
      else:
9826 
        iprot.skip(ftype)
9827 
      iprot.readFieldEnd()
9828 
    iprot.readStructEnd()
9829 
 
9830 
  def write(self, oprot):
9831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9833 
      return
3064 chandransh 9834 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9835 
    if self.type is not None:
9836 
      oprot.writeFieldBegin('type', TType.I64, 1)
9837 
      oprot.writeI64(self.type)
94 ashish 9838 
      oprot.writeFieldEnd()
4444 rajveer 9839 
    if self.warehouseId is not None:
9840 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9841 
      oprot.writeI64(self.warehouseId)
9842 
      oprot.writeFieldEnd()
4394 rajveer 9843 
    if self.status is not None:
4444 rajveer 9844 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9845 
      oprot.writeI64(self.status)
3064 chandransh 9846 
      oprot.writeFieldEnd()
4394 rajveer 9847 
    if self.timestamp is not None:
4444 rajveer 9848 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9849 
      oprot.writeI64(self.timestamp)
9850 
      oprot.writeFieldEnd()
94 ashish 9851 
    oprot.writeFieldStop()
9852 
    oprot.writeStructEnd()
9853 
 
3431 rajveer 9854 
  def validate(self):
9855 
    return
9856 
 
9857 
 
94 ashish 9858 
  def __repr__(self):
9859 
    L = ['%s=%r' % (key, value)
9860 
      for key, value in self.__dict__.iteritems()]
9861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9862 
 
9863 
  def __eq__(self, other):
9864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9865 
 
9866 
  def __ne__(self, other):
9867 
    return not (self == other)
9868 
 
3064 chandransh 9869 
class getAlerts_result:
94 ashish 9870 
  """
9871 
  Attributes:
9872 
   - success
9873 
  """
9874 
 
9875 
  thrift_spec = (
3064 chandransh 9876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9877 
  )
9878 
 
3064 chandransh 9879 
  def __init__(self, success=None,):
94 ashish 9880 
    self.success = success
9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      if fid == 0:
3064 chandransh 9892 
        if ftype == TType.LIST:
9893 
          self.success = []
4999 phani.kuma 9894 
          (_etype178, _size175) = iprot.readListBegin()
9895 
          for _i179 in xrange(_size175):
9896 
            _elem180 = Alert()
9897 
            _elem180.read(iprot)
9898 
            self.success.append(_elem180)
3064 chandransh 9899 
          iprot.readListEnd()
94 ashish 9900 
        else:
9901 
          iprot.skip(ftype)
9902 
      else:
9903 
        iprot.skip(ftype)
9904 
      iprot.readFieldEnd()
9905 
    iprot.readStructEnd()
9906 
 
9907 
  def write(self, oprot):
9908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9910 
      return
3064 chandransh 9911 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9912 
    if self.success is not None:
3064 chandransh 9913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 9915 
      for iter181 in self.success:
9916 
        iter181.write(oprot)
3064 chandransh 9917 
      oprot.writeListEnd()
94 ashish 9918 
      oprot.writeFieldEnd()
9919 
    oprot.writeFieldStop()
9920 
    oprot.writeStructEnd()
9921 
 
3431 rajveer 9922 
  def validate(self):
9923 
    return
9924 
 
9925 
 
94 ashish 9926 
  def __repr__(self):
9927 
    L = ['%s=%r' % (key, value)
9928 
      for key, value in self.__dict__.iteritems()]
9929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9930 
 
9931 
  def __eq__(self, other):
9932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9933 
 
9934 
  def __ne__(self, other):
9935 
    return not (self == other)
9936 
 
4394 rajveer 9937 
class addAlert_args:
94 ashish 9938 
  """
9939 
  Attributes:
3064 chandransh 9940 
   - type
4444 rajveer 9941 
   - warehouseId
4394 rajveer 9942 
   - description
94 ashish 9943 
  """
9944 
 
9945 
  thrift_spec = (
9946 
    None, # 0
4394 rajveer 9947 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9948 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9949 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9950 
  )
9951 
 
4444 rajveer 9952 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9953 
    self.type = type
4444 rajveer 9954 
    self.warehouseId = warehouseId
4394 rajveer 9955 
    self.description = description
94 ashish 9956 
 
9957 
  def read(self, iprot):
9958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9960 
      return
9961 
    iprot.readStructBegin()
9962 
    while True:
9963 
      (fname, ftype, fid) = iprot.readFieldBegin()
9964 
      if ftype == TType.STOP:
9965 
        break
9966 
      if fid == 1:
9967 
        if ftype == TType.I64:
4394 rajveer 9968 
          self.type = iprot.readI64();
94 ashish 9969 
        else:
9970 
          iprot.skip(ftype)
3064 chandransh 9971 
      elif fid == 2:
4444 rajveer 9972 
        if ftype == TType.I64:
9973 
          self.warehouseId = iprot.readI64();
9974 
        else:
9975 
          iprot.skip(ftype)
9976 
      elif fid == 3:
3064 chandransh 9977 
        if ftype == TType.STRING:
4394 rajveer 9978 
          self.description = iprot.readString();
3064 chandransh 9979 
        else:
9980 
          iprot.skip(ftype)
94 ashish 9981 
      else:
9982 
        iprot.skip(ftype)
9983 
      iprot.readFieldEnd()
9984 
    iprot.readStructEnd()
9985 
 
9986 
  def write(self, oprot):
9987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9989 
      return
4394 rajveer 9990 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9991 
    if self.type is not None:
4394 rajveer 9992 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9993 
      oprot.writeI64(self.type)
9994 
      oprot.writeFieldEnd()
4444 rajveer 9995 
    if self.warehouseId is not None:
9996 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9997 
      oprot.writeI64(self.warehouseId)
9998 
      oprot.writeFieldEnd()
4394 rajveer 9999 
    if self.description is not None:
4444 rajveer 10000 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10001 
      oprot.writeString(self.description)
3064 chandransh 10002 
      oprot.writeFieldEnd()
94 ashish 10003 
    oprot.writeFieldStop()
10004 
    oprot.writeStructEnd()
10005 
 
3431 rajveer 10006 
  def validate(self):
10007 
    return
10008 
 
10009 
 
94 ashish 10010 
  def __repr__(self):
10011 
    L = ['%s=%r' % (key, value)
10012 
      for key, value in self.__dict__.iteritems()]
10013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10014 
 
10015 
  def __eq__(self, other):
10016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10017 
 
10018 
  def __ne__(self, other):
10019 
    return not (self == other)
10020 
 
4394 rajveer 10021 
class addAlert_result:
3064 chandransh 10022 
 
10023 
  thrift_spec = (
10024 
  )
10025 
 
10026 
  def read(self, iprot):
10027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10029 
      return
10030 
    iprot.readStructBegin()
10031 
    while True:
10032 
      (fname, ftype, fid) = iprot.readFieldBegin()
10033 
      if ftype == TType.STOP:
10034 
        break
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
4394 rajveer 10044 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10045 
    oprot.writeFieldStop()
10046 
    oprot.writeStructEnd()
10047 
 
3431 rajveer 10048 
  def validate(self):
10049 
    return
10050 
 
10051 
 
3064 chandransh 10052 
  def __repr__(self):
10053 
    L = ['%s=%r' % (key, value)
10054 
      for key, value in self.__dict__.iteritems()]
10055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10056 
 
10057 
  def __eq__(self, other):
10058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10059 
 
10060 
  def __ne__(self, other):
10061 
    return not (self == other)
10062 
 
4444 rajveer 10063 
class markAlertsAsSeen_args:
10064 
  """
10065 
  Attributes:
10066 
   - warehouseId
10067 
  """
10068 
 
10069 
  thrift_spec = (
10070 
    None, # 0
10071 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10072 
  )
10073 
 
10074 
  def __init__(self, warehouseId=None,):
10075 
    self.warehouseId = warehouseId
10076 
 
10077 
  def read(self, iprot):
10078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10080 
      return
10081 
    iprot.readStructBegin()
10082 
    while True:
10083 
      (fname, ftype, fid) = iprot.readFieldBegin()
10084 
      if ftype == TType.STOP:
10085 
        break
10086 
      if fid == 1:
10087 
        if ftype == TType.I64:
10088 
          self.warehouseId = iprot.readI64();
10089 
        else:
10090 
          iprot.skip(ftype)
10091 
      else:
10092 
        iprot.skip(ftype)
10093 
      iprot.readFieldEnd()
10094 
    iprot.readStructEnd()
10095 
 
10096 
  def write(self, oprot):
10097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10099 
      return
10100 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10101 
    if self.warehouseId is not None:
10102 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10103 
      oprot.writeI64(self.warehouseId)
10104 
      oprot.writeFieldEnd()
10105 
    oprot.writeFieldStop()
10106 
    oprot.writeStructEnd()
10107 
 
10108 
  def validate(self):
10109 
    return
10110 
 
10111 
 
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 markAlertsAsSeen_result:
10124 
 
10125 
  thrift_spec = (
10126 
  )
10127 
 
10128 
  def read(self, iprot):
10129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10131 
      return
10132 
    iprot.readStructBegin()
10133 
    while True:
10134 
      (fname, ftype, fid) = iprot.readFieldBegin()
10135 
      if ftype == TType.STOP:
10136 
        break
10137 
      else:
10138 
        iprot.skip(ftype)
10139 
      iprot.readFieldEnd()
10140 
    iprot.readStructEnd()
10141 
 
10142 
  def write(self, oprot):
10143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10145 
      return
10146 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10147 
    oprot.writeFieldStop()
10148 
    oprot.writeStructEnd()
10149 
 
10150 
  def validate(self):
10151 
    return
10152 
 
10153 
 
10154 
  def __repr__(self):
10155 
    L = ['%s=%r' % (key, value)
10156 
      for key, value in self.__dict__.iteritems()]
10157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10158 
 
10159 
  def __eq__(self, other):
10160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10161 
 
10162 
  def __ne__(self, other):
10163 
    return not (self == other)
10164 
 
3064 chandransh 10165 
class getValidOrderCount_args:
10166 
 
10167 
  thrift_spec = (
10168 
  )
10169 
 
10170 
  def read(self, iprot):
10171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10173 
      return
10174 
    iprot.readStructBegin()
10175 
    while True:
10176 
      (fname, ftype, fid) = iprot.readFieldBegin()
10177 
      if ftype == TType.STOP:
10178 
        break
10179 
      else:
10180 
        iprot.skip(ftype)
10181 
      iprot.readFieldEnd()
10182 
    iprot.readStructEnd()
10183 
 
10184 
  def write(self, oprot):
10185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10187 
      return
10188 
    oprot.writeStructBegin('getValidOrderCount_args')
10189 
    oprot.writeFieldStop()
10190 
    oprot.writeStructEnd()
10191 
 
3431 rajveer 10192 
  def validate(self):
10193 
    return
10194 
 
10195 
 
3064 chandransh 10196 
  def __repr__(self):
10197 
    L = ['%s=%r' % (key, value)
10198 
      for key, value in self.__dict__.iteritems()]
10199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10200 
 
10201 
  def __eq__(self, other):
10202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10203 
 
10204 
  def __ne__(self, other):
10205 
    return not (self == other)
10206 
 
10207 
class getValidOrderCount_result:
94 ashish 10208 
  """
10209 
  Attributes:
10210 
   - success
10211 
  """
10212 
 
10213 
  thrift_spec = (
3064 chandransh 10214 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10215 
  )
10216 
 
3064 chandransh 10217 
  def __init__(self, success=None,):
94 ashish 10218 
    self.success = success
10219 
 
10220 
  def read(self, iprot):
10221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10223 
      return
10224 
    iprot.readStructBegin()
10225 
    while True:
10226 
      (fname, ftype, fid) = iprot.readFieldBegin()
10227 
      if ftype == TType.STOP:
10228 
        break
10229 
      if fid == 0:
3064 chandransh 10230 
        if ftype == TType.I64:
10231 
          self.success = iprot.readI64();
94 ashish 10232 
        else:
10233 
          iprot.skip(ftype)
10234 
      else:
10235 
        iprot.skip(ftype)
10236 
      iprot.readFieldEnd()
10237 
    iprot.readStructEnd()
10238 
 
10239 
  def write(self, oprot):
10240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10242 
      return
3064 chandransh 10243 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10244 
    if self.success is not None:
3064 chandransh 10245 
      oprot.writeFieldBegin('success', TType.I64, 0)
10246 
      oprot.writeI64(self.success)
94 ashish 10247 
      oprot.writeFieldEnd()
10248 
    oprot.writeFieldStop()
10249 
    oprot.writeStructEnd()
10250 
 
3431 rajveer 10251 
  def validate(self):
10252 
    return
10253 
 
10254 
 
94 ashish 10255 
  def __repr__(self):
10256 
    L = ['%s=%r' % (key, value)
10257 
      for key, value in self.__dict__.iteritems()]
10258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10259 
 
10260 
  def __eq__(self, other):
10261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10262 
 
10263 
  def __ne__(self, other):
10264 
    return not (self == other)
10265 
 
3064 chandransh 10266 
class getNoOfCustomersWithSuccessfulTransaction_args:
10267 
 
10268 
  thrift_spec = (
10269 
  )
10270 
 
10271 
  def read(self, iprot):
10272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10274 
      return
10275 
    iprot.readStructBegin()
10276 
    while True:
10277 
      (fname, ftype, fid) = iprot.readFieldBegin()
10278 
      if ftype == TType.STOP:
10279 
        break
10280 
      else:
10281 
        iprot.skip(ftype)
10282 
      iprot.readFieldEnd()
10283 
    iprot.readStructEnd()
10284 
 
10285 
  def write(self, oprot):
10286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10288 
      return
10289 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
3431 rajveer 10293 
  def validate(self):
10294 
    return
10295 
 
10296 
 
3064 chandransh 10297 
  def __repr__(self):
10298 
    L = ['%s=%r' % (key, value)
10299 
      for key, value in self.__dict__.iteritems()]
10300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10301 
 
10302 
  def __eq__(self, other):
10303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10304 
 
10305 
  def __ne__(self, other):
10306 
    return not (self == other)
10307 
 
10308 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10309 
  """
10310 
  Attributes:
3064 chandransh 10311 
   - success
94 ashish 10312 
  """
10313 
 
10314 
  thrift_spec = (
3064 chandransh 10315 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10316 
  )
10317 
 
3064 chandransh 10318 
  def __init__(self, success=None,):
10319 
    self.success = success
94 ashish 10320 
 
10321 
  def read(self, iprot):
10322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10324 
      return
10325 
    iprot.readStructBegin()
10326 
    while True:
10327 
      (fname, ftype, fid) = iprot.readFieldBegin()
10328 
      if ftype == TType.STOP:
10329 
        break
3064 chandransh 10330 
      if fid == 0:
94 ashish 10331 
        if ftype == TType.I64:
3064 chandransh 10332 
          self.success = iprot.readI64();
94 ashish 10333 
        else:
10334 
          iprot.skip(ftype)
10335 
      else:
10336 
        iprot.skip(ftype)
10337 
      iprot.readFieldEnd()
10338 
    iprot.readStructEnd()
10339 
 
10340 
  def write(self, oprot):
10341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10343 
      return
3064 chandransh 10344 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10345 
    if self.success is not None:
3064 chandransh 10346 
      oprot.writeFieldBegin('success', TType.I64, 0)
10347 
      oprot.writeI64(self.success)
94 ashish 10348 
      oprot.writeFieldEnd()
10349 
    oprot.writeFieldStop()
10350 
    oprot.writeStructEnd()
10351 
 
3431 rajveer 10352 
  def validate(self):
10353 
    return
10354 
 
10355 
 
94 ashish 10356 
  def __repr__(self):
10357 
    L = ['%s=%r' % (key, value)
10358 
      for key, value in self.__dict__.iteritems()]
10359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10360 
 
10361 
  def __eq__(self, other):
10362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10363 
 
10364 
  def __ne__(self, other):
10365 
    return not (self == other)
10366 
 
3064 chandransh 10367 
class getValidOrdersAmountRange_args:
10368 
 
10369 
  thrift_spec = (
10370 
  )
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      else:
10382 
        iprot.skip(ftype)
10383 
      iprot.readFieldEnd()
10384 
    iprot.readStructEnd()
10385 
 
10386 
  def write(self, oprot):
10387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10389 
      return
10390 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10391 
    oprot.writeFieldStop()
10392 
    oprot.writeStructEnd()
10393 
 
3431 rajveer 10394 
  def validate(self):
10395 
    return
10396 
 
10397 
 
3064 chandransh 10398 
  def __repr__(self):
10399 
    L = ['%s=%r' % (key, value)
10400 
      for key, value in self.__dict__.iteritems()]
10401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10402 
 
10403 
  def __eq__(self, other):
10404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10405 
 
10406 
  def __ne__(self, other):
10407 
    return not (self == other)
10408 
 
10409 
class getValidOrdersAmountRange_result:
94 ashish 10410 
  """
10411 
  Attributes:
10412 
   - success
10413 
  """
10414 
 
10415 
  thrift_spec = (
3064 chandransh 10416 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10417 
  )
10418 
 
3064 chandransh 10419 
  def __init__(self, success=None,):
94 ashish 10420 
    self.success = success
10421 
 
10422 
  def read(self, iprot):
10423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10425 
      return
10426 
    iprot.readStructBegin()
10427 
    while True:
10428 
      (fname, ftype, fid) = iprot.readFieldBegin()
10429 
      if ftype == TType.STOP:
10430 
        break
10431 
      if fid == 0:
483 rajveer 10432 
        if ftype == TType.LIST:
10433 
          self.success = []
4999 phani.kuma 10434 
          (_etype185, _size182) = iprot.readListBegin()
10435 
          for _i186 in xrange(_size182):
10436 
            _elem187 = iprot.readDouble();
10437 
            self.success.append(_elem187)
483 rajveer 10438 
          iprot.readListEnd()
94 ashish 10439 
        else:
10440 
          iprot.skip(ftype)
10441 
      else:
10442 
        iprot.skip(ftype)
10443 
      iprot.readFieldEnd()
10444 
    iprot.readStructEnd()
10445 
 
10446 
  def write(self, oprot):
10447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10449 
      return
3064 chandransh 10450 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10451 
    if self.success is not None:
483 rajveer 10452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10453 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4999 phani.kuma 10454 
      for iter188 in self.success:
10455 
        oprot.writeDouble(iter188)
483 rajveer 10456 
      oprot.writeListEnd()
94 ashish 10457 
      oprot.writeFieldEnd()
10458 
    oprot.writeFieldStop()
10459 
    oprot.writeStructEnd()
10460 
 
3431 rajveer 10461 
  def validate(self):
10462 
    return
10463 
 
10464 
 
94 ashish 10465 
  def __repr__(self):
10466 
    L = ['%s=%r' % (key, value)
10467 
      for key, value in self.__dict__.iteritems()]
10468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10469 
 
10470 
  def __eq__(self, other):
10471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10472 
 
10473 
  def __ne__(self, other):
10474 
    return not (self == other)
10475 
 
3064 chandransh 10476 
class getValidOrders_args:
1528 ankur.sing 10477 
  """
10478 
  Attributes:
3064 chandransh 10479 
   - limit
1528 ankur.sing 10480 
  """
10481 
 
10482 
  thrift_spec = (
10483 
    None, # 0
3064 chandransh 10484 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10485 
  )
10486 
 
3064 chandransh 10487 
  def __init__(self, limit=None,):
10488 
    self.limit = limit
1528 ankur.sing 10489 
 
10490 
  def read(self, iprot):
10491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10493 
      return
10494 
    iprot.readStructBegin()
10495 
    while True:
10496 
      (fname, ftype, fid) = iprot.readFieldBegin()
10497 
      if ftype == TType.STOP:
10498 
        break
10499 
      if fid == 1:
10500 
        if ftype == TType.I64:
3064 chandransh 10501 
          self.limit = iprot.readI64();
1528 ankur.sing 10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      else:
10505 
        iprot.skip(ftype)
10506 
      iprot.readFieldEnd()
10507 
    iprot.readStructEnd()
10508 
 
10509 
  def write(self, oprot):
10510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10512 
      return
3064 chandransh 10513 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10514 
    if self.limit is not None:
3064 chandransh 10515 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10516 
      oprot.writeI64(self.limit)
1528 ankur.sing 10517 
      oprot.writeFieldEnd()
10518 
    oprot.writeFieldStop()
10519 
    oprot.writeStructEnd()
10520 
 
3431 rajveer 10521 
  def validate(self):
10522 
    return
10523 
 
10524 
 
1528 ankur.sing 10525 
  def __repr__(self):
10526 
    L = ['%s=%r' % (key, value)
10527 
      for key, value in self.__dict__.iteritems()]
10528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10529 
 
10530 
  def __eq__(self, other):
10531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10532 
 
10533 
  def __ne__(self, other):
10534 
    return not (self == other)
10535 
 
3064 chandransh 10536 
class getValidOrders_result:
1528 ankur.sing 10537 
  """
10538 
  Attributes:
10539 
   - success
10540 
  """
10541 
 
10542 
  thrift_spec = (
3064 chandransh 10543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10544 
  )
10545 
 
3064 chandransh 10546 
  def __init__(self, success=None,):
1528 ankur.sing 10547 
    self.success = success
10548 
 
10549 
  def read(self, iprot):
10550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10552 
      return
10553 
    iprot.readStructBegin()
10554 
    while True:
10555 
      (fname, ftype, fid) = iprot.readFieldBegin()
10556 
      if ftype == TType.STOP:
10557 
        break
10558 
      if fid == 0:
3064 chandransh 10559 
        if ftype == TType.LIST:
10560 
          self.success = []
4999 phani.kuma 10561 
          (_etype192, _size189) = iprot.readListBegin()
10562 
          for _i193 in xrange(_size189):
10563 
            _elem194 = Order()
10564 
            _elem194.read(iprot)
10565 
            self.success.append(_elem194)
3064 chandransh 10566 
          iprot.readListEnd()
1528 ankur.sing 10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      else:
10570 
        iprot.skip(ftype)
10571 
      iprot.readFieldEnd()
10572 
    iprot.readStructEnd()
10573 
 
10574 
  def write(self, oprot):
10575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10577 
      return
3064 chandransh 10578 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10579 
    if self.success is not None:
3064 chandransh 10580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 10582 
      for iter195 in self.success:
10583 
        iter195.write(oprot)
3064 chandransh 10584 
      oprot.writeListEnd()
1528 ankur.sing 10585 
      oprot.writeFieldEnd()
10586 
    oprot.writeFieldStop()
10587 
    oprot.writeStructEnd()
10588 
 
3431 rajveer 10589 
  def validate(self):
10590 
    return
10591 
 
10592 
 
1528 ankur.sing 10593 
  def __repr__(self):
10594 
    L = ['%s=%r' % (key, value)
10595 
      for key, value in self.__dict__.iteritems()]
10596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10597 
 
10598 
  def __eq__(self, other):
10599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10600 
 
10601 
  def __ne__(self, other):
10602 
    return not (self == other)
10603 
 
1220 chandransh 10604 
class batchOrders_args:
10605 
  """
10606 
  Attributes:
10607 
   - warehouseId
10608 
  """
10609 
 
10610 
  thrift_spec = (
10611 
    None, # 0
10612 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10613 
  )
10614 
 
10615 
  def __init__(self, warehouseId=None,):
10616 
    self.warehouseId = warehouseId
10617 
 
10618 
  def read(self, iprot):
10619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10621 
      return
10622 
    iprot.readStructBegin()
10623 
    while True:
10624 
      (fname, ftype, fid) = iprot.readFieldBegin()
10625 
      if ftype == TType.STOP:
10626 
        break
10627 
      if fid == 1:
10628 
        if ftype == TType.I64:
10629 
          self.warehouseId = iprot.readI64();
10630 
        else:
10631 
          iprot.skip(ftype)
10632 
      else:
10633 
        iprot.skip(ftype)
10634 
      iprot.readFieldEnd()
10635 
    iprot.readStructEnd()
10636 
 
10637 
  def write(self, oprot):
10638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10640 
      return
10641 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10642 
    if self.warehouseId is not None:
1220 chandransh 10643 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10644 
      oprot.writeI64(self.warehouseId)
10645 
      oprot.writeFieldEnd()
10646 
    oprot.writeFieldStop()
10647 
    oprot.writeStructEnd()
10648 
 
3431 rajveer 10649 
  def validate(self):
10650 
    return
10651 
 
10652 
 
1220 chandransh 10653 
  def __repr__(self):
10654 
    L = ['%s=%r' % (key, value)
10655 
      for key, value in self.__dict__.iteritems()]
10656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10657 
 
10658 
  def __eq__(self, other):
10659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10660 
 
10661 
  def __ne__(self, other):
10662 
    return not (self == other)
10663 
 
10664 
class batchOrders_result:
10665 
  """
10666 
  Attributes:
10667 
   - success
10668 
   - ex
10669 
  """
10670 
 
10671 
  thrift_spec = (
10672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10674 
  )
10675 
 
10676 
  def __init__(self, success=None, ex=None,):
10677 
    self.success = success
10678 
    self.ex = ex
10679 
 
10680 
  def read(self, iprot):
10681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10683 
      return
10684 
    iprot.readStructBegin()
10685 
    while True:
10686 
      (fname, ftype, fid) = iprot.readFieldBegin()
10687 
      if ftype == TType.STOP:
10688 
        break
10689 
      if fid == 0:
10690 
        if ftype == TType.LIST:
10691 
          self.success = []
4999 phani.kuma 10692 
          (_etype199, _size196) = iprot.readListBegin()
10693 
          for _i200 in xrange(_size196):
10694 
            _elem201 = Order()
10695 
            _elem201.read(iprot)
10696 
            self.success.append(_elem201)
1220 chandransh 10697 
          iprot.readListEnd()
10698 
        else:
10699 
          iprot.skip(ftype)
10700 
      elif fid == 1:
10701 
        if ftype == TType.STRUCT:
10702 
          self.ex = TransactionServiceException()
10703 
          self.ex.read(iprot)
10704 
        else:
10705 
          iprot.skip(ftype)
10706 
      else:
10707 
        iprot.skip(ftype)
10708 
      iprot.readFieldEnd()
10709 
    iprot.readStructEnd()
10710 
 
10711 
  def write(self, oprot):
10712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10714 
      return
10715 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10716 
    if self.success is not None:
1220 chandransh 10717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 10719 
      for iter202 in self.success:
10720 
        iter202.write(oprot)
1220 chandransh 10721 
      oprot.writeListEnd()
10722 
      oprot.writeFieldEnd()
3431 rajveer 10723 
    if self.ex is not None:
1220 chandransh 10724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10725 
      self.ex.write(oprot)
10726 
      oprot.writeFieldEnd()
10727 
    oprot.writeFieldStop()
10728 
    oprot.writeStructEnd()
10729 
 
3431 rajveer 10730 
  def validate(self):
10731 
    return
10732 
 
10733 
 
1220 chandransh 10734 
  def __repr__(self):
10735 
    L = ['%s=%r' % (key, value)
10736 
      for key, value in self.__dict__.iteritems()]
10737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10738 
 
10739 
  def __eq__(self, other):
10740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10741 
 
10742 
  def __ne__(self, other):
10743 
    return not (self == other)
10744 
 
1208 chandransh 10745 
class markOrderAsOutOfStock_args:
10746 
  """
10747 
  Attributes:
10748 
   - orderId
10749 
  """
10750 
 
10751 
  thrift_spec = (
10752 
    None, # 0
10753 
    (1, TType.I64, 'orderId', None, None, ), # 1
10754 
  )
10755 
 
10756 
  def __init__(self, orderId=None,):
10757 
    self.orderId = orderId
10758 
 
10759 
  def read(self, iprot):
10760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10762 
      return
10763 
    iprot.readStructBegin()
10764 
    while True:
10765 
      (fname, ftype, fid) = iprot.readFieldBegin()
10766 
      if ftype == TType.STOP:
10767 
        break
10768 
      if fid == 1:
10769 
        if ftype == TType.I64:
10770 
          self.orderId = iprot.readI64();
10771 
        else:
10772 
          iprot.skip(ftype)
10773 
      else:
10774 
        iprot.skip(ftype)
10775 
      iprot.readFieldEnd()
10776 
    iprot.readStructEnd()
10777 
 
10778 
  def write(self, oprot):
10779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10781 
      return
10782 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10783 
    if self.orderId is not None:
1208 chandransh 10784 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10785 
      oprot.writeI64(self.orderId)
10786 
      oprot.writeFieldEnd()
10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
3431 rajveer 10790 
  def validate(self):
10791 
    return
10792 
 
10793 
 
1208 chandransh 10794 
  def __repr__(self):
10795 
    L = ['%s=%r' % (key, value)
10796 
      for key, value in self.__dict__.iteritems()]
10797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10798 
 
10799 
  def __eq__(self, other):
10800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10801 
 
10802 
  def __ne__(self, other):
10803 
    return not (self == other)
10804 
 
10805 
class markOrderAsOutOfStock_result:
10806 
  """
10807 
  Attributes:
10808 
   - success
10809 
   - ex
10810 
  """
10811 
 
10812 
  thrift_spec = (
10813 
    (0, TType.BOOL, 'success', None, None, ), # 0
10814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10815 
  )
10816 
 
10817 
  def __init__(self, success=None, ex=None,):
10818 
    self.success = success
10819 
    self.ex = ex
10820 
 
10821 
  def read(self, iprot):
10822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10824 
      return
10825 
    iprot.readStructBegin()
10826 
    while True:
10827 
      (fname, ftype, fid) = iprot.readFieldBegin()
10828 
      if ftype == TType.STOP:
10829 
        break
10830 
      if fid == 0:
10831 
        if ftype == TType.BOOL:
10832 
          self.success = iprot.readBool();
10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      elif fid == 1:
10836 
        if ftype == TType.STRUCT:
10837 
          self.ex = TransactionServiceException()
10838 
          self.ex.read(iprot)
10839 
        else:
10840 
          iprot.skip(ftype)
10841 
      else:
10842 
        iprot.skip(ftype)
10843 
      iprot.readFieldEnd()
10844 
    iprot.readStructEnd()
10845 
 
10846 
  def write(self, oprot):
10847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10849 
      return
10850 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10851 
    if self.success is not None:
1208 chandransh 10852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10853 
      oprot.writeBool(self.success)
10854 
      oprot.writeFieldEnd()
3431 rajveer 10855 
    if self.ex is not None:
1208 chandransh 10856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10857 
      self.ex.write(oprot)
10858 
      oprot.writeFieldEnd()
10859 
    oprot.writeFieldStop()
10860 
    oprot.writeStructEnd()
10861 
 
3431 rajveer 10862 
  def validate(self):
10863 
    return
10864 
 
10865 
 
1208 chandransh 10866 
  def __repr__(self):
10867 
    L = ['%s=%r' % (key, value)
10868 
      for key, value in self.__dict__.iteritems()]
10869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10870 
 
10871 
  def __eq__(self, other):
10872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10873 
 
10874 
  def __ne__(self, other):
10875 
    return not (self == other)
10876 
 
3064 chandransh 10877 
class verifyOrder_args:
759 chandransh 10878 
  """
10879 
  Attributes:
3064 chandransh 10880 
   - orderId
759 chandransh 10881 
  """
10882 
 
10883 
  thrift_spec = (
10884 
    None, # 0
3064 chandransh 10885 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10886 
  )
10887 
 
3064 chandransh 10888 
  def __init__(self, orderId=None,):
10889 
    self.orderId = orderId
759 chandransh 10890 
 
10891 
  def read(self, iprot):
10892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10894 
      return
10895 
    iprot.readStructBegin()
10896 
    while True:
10897 
      (fname, ftype, fid) = iprot.readFieldBegin()
10898 
      if ftype == TType.STOP:
10899 
        break
10900 
      if fid == 1:
10901 
        if ftype == TType.I64:
3064 chandransh 10902 
          self.orderId = iprot.readI64();
759 chandransh 10903 
        else:
10904 
          iprot.skip(ftype)
10905 
      else:
10906 
        iprot.skip(ftype)
10907 
      iprot.readFieldEnd()
10908 
    iprot.readStructEnd()
10909 
 
10910 
  def write(self, oprot):
10911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10913 
      return
3064 chandransh 10914 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10915 
    if self.orderId is not None:
3064 chandransh 10916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10917 
      oprot.writeI64(self.orderId)
759 chandransh 10918 
      oprot.writeFieldEnd()
10919 
    oprot.writeFieldStop()
10920 
    oprot.writeStructEnd()
10921 
 
3431 rajveer 10922 
  def validate(self):
10923 
    return
10924 
 
10925 
 
759 chandransh 10926 
  def __repr__(self):
10927 
    L = ['%s=%r' % (key, value)
10928 
      for key, value in self.__dict__.iteritems()]
10929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10930 
 
10931 
  def __eq__(self, other):
10932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10933 
 
10934 
  def __ne__(self, other):
10935 
    return not (self == other)
10936 
 
3064 chandransh 10937 
class verifyOrder_result:
759 chandransh 10938 
  """
10939 
  Attributes:
10940 
   - success
10941 
   - ex
10942 
  """
10943 
 
10944 
  thrift_spec = (
10945 
    (0, TType.BOOL, 'success', None, None, ), # 0
10946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10947 
  )
10948 
 
10949 
  def __init__(self, success=None, ex=None,):
10950 
    self.success = success
10951 
    self.ex = ex
10952 
 
10953 
  def read(self, iprot):
10954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10956 
      return
10957 
    iprot.readStructBegin()
10958 
    while True:
10959 
      (fname, ftype, fid) = iprot.readFieldBegin()
10960 
      if ftype == TType.STOP:
10961 
        break
10962 
      if fid == 0:
10963 
        if ftype == TType.BOOL:
10964 
          self.success = iprot.readBool();
10965 
        else:
10966 
          iprot.skip(ftype)
10967 
      elif fid == 1:
10968 
        if ftype == TType.STRUCT:
10969 
          self.ex = TransactionServiceException()
10970 
          self.ex.read(iprot)
10971 
        else:
10972 
          iprot.skip(ftype)
10973 
      else:
10974 
        iprot.skip(ftype)
10975 
      iprot.readFieldEnd()
10976 
    iprot.readStructEnd()
10977 
 
10978 
  def write(self, oprot):
10979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10981 
      return
3064 chandransh 10982 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10983 
    if self.success is not None:
759 chandransh 10984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10985 
      oprot.writeBool(self.success)
10986 
      oprot.writeFieldEnd()
3431 rajveer 10987 
    if self.ex is not None:
759 chandransh 10988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10989 
      self.ex.write(oprot)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
3431 rajveer 10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
759 chandransh 10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
3064 chandransh 11009 
class acceptOrder_args:
1113 chandransh 11010 
  """
11011 
  Attributes:
3064 chandransh 11012 
   - orderId
1113 chandransh 11013 
  """
11014 
 
11015 
  thrift_spec = (
11016 
    None, # 0
3064 chandransh 11017 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11018 
  )
11019 
 
3064 chandransh 11020 
  def __init__(self, orderId=None,):
11021 
    self.orderId = orderId
1113 chandransh 11022 
 
11023 
  def read(self, iprot):
11024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11026 
      return
11027 
    iprot.readStructBegin()
11028 
    while True:
11029 
      (fname, ftype, fid) = iprot.readFieldBegin()
11030 
      if ftype == TType.STOP:
11031 
        break
11032 
      if fid == 1:
11033 
        if ftype == TType.I64:
3064 chandransh 11034 
          self.orderId = iprot.readI64();
1113 chandransh 11035 
        else:
11036 
          iprot.skip(ftype)
11037 
      else:
11038 
        iprot.skip(ftype)
11039 
      iprot.readFieldEnd()
11040 
    iprot.readStructEnd()
11041 
 
11042 
  def write(self, oprot):
11043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11045 
      return
3064 chandransh 11046 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11047 
    if self.orderId is not None:
3064 chandransh 11048 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11049 
      oprot.writeI64(self.orderId)
1113 chandransh 11050 
      oprot.writeFieldEnd()
11051 
    oprot.writeFieldStop()
11052 
    oprot.writeStructEnd()
11053 
 
3431 rajveer 11054 
  def validate(self):
11055 
    return
11056 
 
11057 
 
1113 chandransh 11058 
  def __repr__(self):
11059 
    L = ['%s=%r' % (key, value)
11060 
      for key, value in self.__dict__.iteritems()]
11061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11062 
 
11063 
  def __eq__(self, other):
11064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11065 
 
11066 
  def __ne__(self, other):
11067 
    return not (self == other)
11068 
 
3064 chandransh 11069 
class acceptOrder_result:
1113 chandransh 11070 
  """
11071 
  Attributes:
11072 
   - success
11073 
   - ex
11074 
  """
11075 
 
11076 
  thrift_spec = (
3064 chandransh 11077 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11079 
  )
11080 
 
11081 
  def __init__(self, success=None, ex=None,):
11082 
    self.success = success
11083 
    self.ex = ex
11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 0:
3064 chandransh 11095 
        if ftype == TType.BOOL:
11096 
          self.success = iprot.readBool();
1113 chandransh 11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      elif fid == 1:
11100 
        if ftype == TType.STRUCT:
11101 
          self.ex = TransactionServiceException()
11102 
          self.ex.read(iprot)
11103 
        else:
11104 
          iprot.skip(ftype)
11105 
      else:
11106 
        iprot.skip(ftype)
11107 
      iprot.readFieldEnd()
11108 
    iprot.readStructEnd()
11109 
 
11110 
  def write(self, oprot):
11111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11113 
      return
3064 chandransh 11114 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11115 
    if self.success is not None:
3064 chandransh 11116 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11117 
      oprot.writeBool(self.success)
1113 chandransh 11118 
      oprot.writeFieldEnd()
3431 rajveer 11119 
    if self.ex is not None:
1113 chandransh 11120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11121 
      self.ex.write(oprot)
11122 
      oprot.writeFieldEnd()
11123 
    oprot.writeFieldStop()
11124 
    oprot.writeStructEnd()
11125 
 
3431 rajveer 11126 
  def validate(self):
11127 
    return
11128 
 
11129 
 
1113 chandransh 11130 
  def __repr__(self):
11131 
    L = ['%s=%r' % (key, value)
11132 
      for key, value in self.__dict__.iteritems()]
11133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11134 
 
11135 
  def __eq__(self, other):
11136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11137 
 
11138 
  def __ne__(self, other):
11139 
    return not (self == other)
11140 
 
3064 chandransh 11141 
class addBillingDetails_args:
1135 chandransh 11142 
  """
11143 
  Attributes:
3064 chandransh 11144 
   - orderId
11145 
   - invoice_number
4658 mandeep.dh 11146 
   - serialNumber
4283 anupam.sin 11147 
   - itemNumber
3064 chandransh 11148 
   - billed_by
4264 rajveer 11149 
   - jacketNumber
4283 anupam.sin 11150 
   - billingType
11151 
   - vendorId
4763 rajveer 11152 
   - authorize
1135 chandransh 11153 
  """
11154 
 
11155 
  thrift_spec = (
11156 
    None, # 0
3064 chandransh 11157 
    (1, TType.I64, 'orderId', None, None, ), # 1
11158 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11159 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11160 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11161 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11162 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11163 
    (7, TType.I64, 'billingType', None, None, ), # 7
11164 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 11165 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11166 
  )
11167 
 
4763 rajveer 11168 
  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 11169 
    self.orderId = orderId
11170 
    self.invoice_number = invoice_number
4658 mandeep.dh 11171 
    self.serialNumber = serialNumber
4283 anupam.sin 11172 
    self.itemNumber = itemNumber
3064 chandransh 11173 
    self.billed_by = billed_by
4264 rajveer 11174 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11175 
    self.billingType = billingType
11176 
    self.vendorId = vendorId
4763 rajveer 11177 
    self.authorize = authorize
1135 chandransh 11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 1:
11189 
        if ftype == TType.I64:
3064 chandransh 11190 
          self.orderId = iprot.readI64();
1135 chandransh 11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      elif fid == 2:
3064 chandransh 11194 
        if ftype == TType.STRING:
11195 
          self.invoice_number = iprot.readString();
1135 chandransh 11196 
        else:
11197 
          iprot.skip(ftype)
3064 chandransh 11198 
      elif fid == 3:
4658 mandeep.dh 11199 
        if ftype == TType.STRING:
11200 
          self.serialNumber = iprot.readString();
3064 chandransh 11201 
        else:
11202 
          iprot.skip(ftype)
11203 
      elif fid == 4:
11204 
        if ftype == TType.STRING:
11205 
          self.itemNumber = iprot.readString();
11206 
        else:
11207 
          iprot.skip(ftype)
11208 
      elif fid == 5:
11209 
        if ftype == TType.STRING:
4283 anupam.sin 11210 
          self.billed_by = iprot.readString();
3064 chandransh 11211 
        else:
11212 
          iprot.skip(ftype)
11213 
      elif fid == 6:
11214 
        if ftype == TType.I64:
4283 anupam.sin 11215 
          self.jacketNumber = iprot.readI64();
11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      elif fid == 7:
11219 
        if ftype == TType.I64:
3064 chandransh 11220 
          self.billingType = iprot.readI64();
11221 
        else:
11222 
          iprot.skip(ftype)
4283 anupam.sin 11223 
      elif fid == 8:
11224 
        if ftype == TType.I64:
11225 
          self.vendorId = iprot.readI64();
11226 
        else:
11227 
          iprot.skip(ftype)
4763 rajveer 11228 
      elif fid == 9:
11229 
        if ftype == TType.BOOL:
11230 
          self.authorize = iprot.readBool();
11231 
        else:
11232 
          iprot.skip(ftype)
1246 chandransh 11233 
      else:
11234 
        iprot.skip(ftype)
11235 
      iprot.readFieldEnd()
11236 
    iprot.readStructEnd()
11237 
 
11238 
  def write(self, oprot):
11239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11241 
      return
4283 anupam.sin 11242 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11243 
    if self.orderId is not None:
3064 chandransh 11244 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11245 
      oprot.writeI64(self.orderId)
1246 chandransh 11246 
      oprot.writeFieldEnd()
4283 anupam.sin 11247 
    if self.invoice_number is not None:
11248 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11249 
      oprot.writeString(self.invoice_number)
1246 chandransh 11250 
      oprot.writeFieldEnd()
4658 mandeep.dh 11251 
    if self.serialNumber is not None:
11252 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11253 
      oprot.writeString(self.serialNumber)
3064 chandransh 11254 
      oprot.writeFieldEnd()
3431 rajveer 11255 
    if self.itemNumber is not None:
3064 chandransh 11256 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11257 
      oprot.writeString(self.itemNumber)
11258 
      oprot.writeFieldEnd()
4283 anupam.sin 11259 
    if self.billed_by is not None:
11260 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11261 
      oprot.writeString(self.billed_by)
3064 chandransh 11262 
      oprot.writeFieldEnd()
4283 anupam.sin 11263 
    if self.jacketNumber is not None:
11264 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11265 
      oprot.writeI64(self.jacketNumber)
11266 
      oprot.writeFieldEnd()
3431 rajveer 11267 
    if self.billingType is not None:
4283 anupam.sin 11268 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11269 
      oprot.writeI64(self.billingType)
11270 
      oprot.writeFieldEnd()
4283 anupam.sin 11271 
    if self.vendorId is not None:
11272 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
11273 
      oprot.writeI64(self.vendorId)
11274 
      oprot.writeFieldEnd()
4763 rajveer 11275 
    if self.authorize is not None:
11276 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11277 
      oprot.writeBool(self.authorize)
11278 
      oprot.writeFieldEnd()
1246 chandransh 11279 
    oprot.writeFieldStop()
11280 
    oprot.writeStructEnd()
11281 
 
3431 rajveer 11282 
  def validate(self):
11283 
    return
11284 
 
11285 
 
1246 chandransh 11286 
  def __repr__(self):
11287 
    L = ['%s=%r' % (key, value)
11288 
      for key, value in self.__dict__.iteritems()]
11289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11290 
 
11291 
  def __eq__(self, other):
11292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11293 
 
11294 
  def __ne__(self, other):
11295 
    return not (self == other)
11296 
 
4283 anupam.sin 11297 
class addBillingDetails_result:
1246 chandransh 11298 
  """
11299 
  Attributes:
3064 chandransh 11300 
   - success
1246 chandransh 11301 
   - ex
11302 
  """
11303 
 
11304 
  thrift_spec = (
3064 chandransh 11305 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11307 
  )
11308 
 
3064 chandransh 11309 
  def __init__(self, success=None, ex=None,):
11310 
    self.success = success
1246 chandransh 11311 
    self.ex = ex
11312 
 
11313 
  def read(self, iprot):
11314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11316 
      return
11317 
    iprot.readStructBegin()
11318 
    while True:
11319 
      (fname, ftype, fid) = iprot.readFieldBegin()
11320 
      if ftype == TType.STOP:
11321 
        break
3064 chandransh 11322 
      if fid == 0:
11323 
        if ftype == TType.BOOL:
11324 
          self.success = iprot.readBool();
11325 
        else:
11326 
          iprot.skip(ftype)
11327 
      elif fid == 1:
1246 chandransh 11328 
        if ftype == TType.STRUCT:
11329 
          self.ex = TransactionServiceException()
11330 
          self.ex.read(iprot)
11331 
        else:
11332 
          iprot.skip(ftype)
11333 
      else:
11334 
        iprot.skip(ftype)
11335 
      iprot.readFieldEnd()
11336 
    iprot.readStructEnd()
11337 
 
11338 
  def write(self, oprot):
11339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11341 
      return
4283 anupam.sin 11342 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11343 
    if self.success is not None:
3064 chandransh 11344 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11345 
      oprot.writeBool(self.success)
11346 
      oprot.writeFieldEnd()
3431 rajveer 11347 
    if self.ex is not None:
1246 chandransh 11348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11349 
      self.ex.write(oprot)
11350 
      oprot.writeFieldEnd()
11351 
    oprot.writeFieldStop()
11352 
    oprot.writeStructEnd()
11353 
 
3431 rajveer 11354 
  def validate(self):
11355 
    return
11356 
 
11357 
 
1246 chandransh 11358 
  def __repr__(self):
11359 
    L = ['%s=%r' % (key, value)
11360 
      for key, value in self.__dict__.iteritems()]
11361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11362 
 
11363 
  def __eq__(self, other):
11364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11365 
 
11366 
  def __ne__(self, other):
11367 
    return not (self == other)
11368 
 
4579 rajveer 11369 
class addInvoiceNumber_args:
11370 
  """
11371 
  Attributes:
11372 
   - orderId
11373 
   - invoiceNumber
4763 rajveer 11374 
   - color
4579 rajveer 11375 
  """
11376 
 
11377 
  thrift_spec = (
11378 
    None, # 0
11379 
    (1, TType.I64, 'orderId', None, None, ), # 1
11380 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11381 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11382 
  )
11383 
 
4763 rajveer 11384 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11385 
    self.orderId = orderId
11386 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11387 
    self.color = color
4579 rajveer 11388 
 
11389 
  def read(self, iprot):
11390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11392 
      return
11393 
    iprot.readStructBegin()
11394 
    while True:
11395 
      (fname, ftype, fid) = iprot.readFieldBegin()
11396 
      if ftype == TType.STOP:
11397 
        break
11398 
      if fid == 1:
11399 
        if ftype == TType.I64:
11400 
          self.orderId = iprot.readI64();
11401 
        else:
11402 
          iprot.skip(ftype)
11403 
      elif fid == 2:
11404 
        if ftype == TType.STRING:
11405 
          self.invoiceNumber = iprot.readString();
11406 
        else:
11407 
          iprot.skip(ftype)
4763 rajveer 11408 
      elif fid == 3:
11409 
        if ftype == TType.STRING:
11410 
          self.color = iprot.readString();
11411 
        else:
11412 
          iprot.skip(ftype)
4579 rajveer 11413 
      else:
11414 
        iprot.skip(ftype)
11415 
      iprot.readFieldEnd()
11416 
    iprot.readStructEnd()
11417 
 
11418 
  def write(self, oprot):
11419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11421 
      return
11422 
    oprot.writeStructBegin('addInvoiceNumber_args')
11423 
    if self.orderId is not None:
11424 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11425 
      oprot.writeI64(self.orderId)
11426 
      oprot.writeFieldEnd()
11427 
    if self.invoiceNumber is not None:
11428 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11429 
      oprot.writeString(self.invoiceNumber)
11430 
      oprot.writeFieldEnd()
4763 rajveer 11431 
    if self.color is not None:
11432 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11433 
      oprot.writeString(self.color)
11434 
      oprot.writeFieldEnd()
4579 rajveer 11435 
    oprot.writeFieldStop()
11436 
    oprot.writeStructEnd()
11437 
 
11438 
  def validate(self):
11439 
    return
11440 
 
11441 
 
11442 
  def __repr__(self):
11443 
    L = ['%s=%r' % (key, value)
11444 
      for key, value in self.__dict__.iteritems()]
11445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11446 
 
11447 
  def __eq__(self, other):
11448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11449 
 
11450 
  def __ne__(self, other):
11451 
    return not (self == other)
11452 
 
11453 
class addInvoiceNumber_result:
11454 
  """
11455 
  Attributes:
11456 
   - ex
11457 
  """
11458 
 
11459 
  thrift_spec = (
11460 
    None, # 0
11461 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11462 
  )
11463 
 
11464 
  def __init__(self, ex=None,):
11465 
    self.ex = ex
11466 
 
11467 
  def read(self, iprot):
11468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11470 
      return
11471 
    iprot.readStructBegin()
11472 
    while True:
11473 
      (fname, ftype, fid) = iprot.readFieldBegin()
11474 
      if ftype == TType.STOP:
11475 
        break
11476 
      if fid == 1:
11477 
        if ftype == TType.STRUCT:
11478 
          self.ex = TransactionServiceException()
11479 
          self.ex.read(iprot)
11480 
        else:
11481 
          iprot.skip(ftype)
11482 
      else:
11483 
        iprot.skip(ftype)
11484 
      iprot.readFieldEnd()
11485 
    iprot.readStructEnd()
11486 
 
11487 
  def write(self, oprot):
11488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11490 
      return
11491 
    oprot.writeStructBegin('addInvoiceNumber_result')
11492 
    if self.ex is not None:
11493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11494 
      self.ex.write(oprot)
11495 
      oprot.writeFieldEnd()
11496 
    oprot.writeFieldStop()
11497 
    oprot.writeStructEnd()
11498 
 
11499 
  def validate(self):
11500 
    return
11501 
 
11502 
 
11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
4910 phani.kuma 11514 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11515 
  """
11516 
  Attributes:
3064 chandransh 11517 
   - warehouseId
1408 ankur.sing 11518 
   - providerId
3064 chandransh 11519 
   - cod
4910 phani.kuma 11520 
   - orderIds
1408 ankur.sing 11521 
  """
11522 
 
11523 
  thrift_spec = (
11524 
    None, # 0
3064 chandransh 11525 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11526 
    (2, TType.I64, 'providerId', None, None, ), # 2
11527 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11528 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11529 
  )
11530 
 
4910 phani.kuma 11531 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11532 
    self.warehouseId = warehouseId
1408 ankur.sing 11533 
    self.providerId = providerId
3064 chandransh 11534 
    self.cod = cod
4910 phani.kuma 11535 
    self.orderIds = orderIds
1408 ankur.sing 11536 
 
11537 
  def read(self, iprot):
11538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11540 
      return
11541 
    iprot.readStructBegin()
11542 
    while True:
11543 
      (fname, ftype, fid) = iprot.readFieldBegin()
11544 
      if ftype == TType.STOP:
11545 
        break
11546 
      if fid == 1:
11547 
        if ftype == TType.I64:
3064 chandransh 11548 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      elif fid == 2:
11552 
        if ftype == TType.I64:
3064 chandransh 11553 
          self.providerId = iprot.readI64();
1408 ankur.sing 11554 
        else:
11555 
          iprot.skip(ftype)
3064 chandransh 11556 
      elif fid == 3:
11557 
        if ftype == TType.BOOL:
11558 
          self.cod = iprot.readBool();
11559 
        else:
11560 
          iprot.skip(ftype)
4910 phani.kuma 11561 
      elif fid == 4:
11562 
        if ftype == TType.LIST:
11563 
          self.orderIds = []
4999 phani.kuma 11564 
          (_etype206, _size203) = iprot.readListBegin()
11565 
          for _i207 in xrange(_size203):
11566 
            _elem208 = iprot.readI64();
11567 
            self.orderIds.append(_elem208)
4910 phani.kuma 11568 
          iprot.readListEnd()
11569 
        else:
11570 
          iprot.skip(ftype)
1408 ankur.sing 11571 
      else:
11572 
        iprot.skip(ftype)
11573 
      iprot.readFieldEnd()
11574 
    iprot.readStructEnd()
11575 
 
11576 
  def write(self, oprot):
11577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11579 
      return
4910 phani.kuma 11580 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11581 
    if self.warehouseId is not None:
3064 chandransh 11582 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11583 
      oprot.writeI64(self.warehouseId)
11584 
      oprot.writeFieldEnd()
3431 rajveer 11585 
    if self.providerId is not None:
3064 chandransh 11586 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11587 
      oprot.writeI64(self.providerId)
11588 
      oprot.writeFieldEnd()
3431 rajveer 11589 
    if self.cod is not None:
3064 chandransh 11590 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11591 
      oprot.writeBool(self.cod)
1408 ankur.sing 11592 
      oprot.writeFieldEnd()
4910 phani.kuma 11593 
    if self.orderIds is not None:
11594 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11595 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4999 phani.kuma 11596 
      for iter209 in self.orderIds:
11597 
        oprot.writeI64(iter209)
4910 phani.kuma 11598 
      oprot.writeListEnd()
11599 
      oprot.writeFieldEnd()
1408 ankur.sing 11600 
    oprot.writeFieldStop()
11601 
    oprot.writeStructEnd()
11602 
 
3431 rajveer 11603 
  def validate(self):
11604 
    return
11605 
 
11606 
 
1408 ankur.sing 11607 
  def __repr__(self):
11608 
    L = ['%s=%r' % (key, value)
11609 
      for key, value in self.__dict__.iteritems()]
11610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11611 
 
11612 
  def __eq__(self, other):
11613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11614 
 
11615 
  def __ne__(self, other):
11616 
    return not (self == other)
11617 
 
4910 phani.kuma 11618 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11619 
  """
11620 
  Attributes:
11621 
   - success
3064 chandransh 11622 
   - ex
1408 ankur.sing 11623 
  """
11624 
 
11625 
  thrift_spec = (
3064 chandransh 11626 
    (0, TType.BOOL, 'success', None, None, ), # 0
11627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11628 
  )
11629 
 
3064 chandransh 11630 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11631 
    self.success = success
3064 chandransh 11632 
    self.ex = ex
1408 ankur.sing 11633 
 
11634 
  def read(self, iprot):
11635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11637 
      return
11638 
    iprot.readStructBegin()
11639 
    while True:
11640 
      (fname, ftype, fid) = iprot.readFieldBegin()
11641 
      if ftype == TType.STOP:
11642 
        break
11643 
      if fid == 0:
3064 chandransh 11644 
        if ftype == TType.BOOL:
11645 
          self.success = iprot.readBool();
1408 ankur.sing 11646 
        else:
11647 
          iprot.skip(ftype)
3064 chandransh 11648 
      elif fid == 1:
11649 
        if ftype == TType.STRUCT:
11650 
          self.ex = TransactionServiceException()
11651 
          self.ex.read(iprot)
11652 
        else:
11653 
          iprot.skip(ftype)
1408 ankur.sing 11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
4910 phani.kuma 11663 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11664 
    if self.success is not None:
3064 chandransh 11665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11666 
      oprot.writeBool(self.success)
1408 ankur.sing 11667 
      oprot.writeFieldEnd()
3431 rajveer 11668 
    if self.ex is not None:
3064 chandransh 11669 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11670 
      self.ex.write(oprot)
11671 
      oprot.writeFieldEnd()
1408 ankur.sing 11672 
    oprot.writeFieldStop()
11673 
    oprot.writeStructEnd()
11674 
 
3431 rajveer 11675 
  def validate(self):
11676 
    return
11677 
 
11678 
 
1408 ankur.sing 11679 
  def __repr__(self):
11680 
    L = ['%s=%r' % (key, value)
11681 
      for key, value in self.__dict__.iteritems()]
11682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11683 
 
11684 
  def __eq__(self, other):
11685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11686 
 
11687 
  def __ne__(self, other):
11688 
    return not (self == other)
11689 
 
4910 phani.kuma 11690 
class markOrdersAsPickedUp_args:
4410 rajveer 11691 
  """
11692 
  Attributes:
11693 
   - providerId
4910 phani.kuma 11694 
   - pickupDetails
4410 rajveer 11695 
  """
11696 
 
11697 
  thrift_spec = (
11698 
    None, # 0
4910 phani.kuma 11699 
    (1, TType.I64, 'providerId', None, None, ), # 1
11700 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11701 
  )
11702 
 
4910 phani.kuma 11703 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11704 
    self.providerId = providerId
4910 phani.kuma 11705 
    self.pickupDetails = pickupDetails
4410 rajveer 11706 
 
11707 
  def read(self, iprot):
11708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11710 
      return
11711 
    iprot.readStructBegin()
11712 
    while True:
11713 
      (fname, ftype, fid) = iprot.readFieldBegin()
11714 
      if ftype == TType.STOP:
11715 
        break
11716 
      if fid == 1:
11717 
        if ftype == TType.I64:
4910 phani.kuma 11718 
          self.providerId = iprot.readI64();
4410 rajveer 11719 
        else:
11720 
          iprot.skip(ftype)
11721 
      elif fid == 2:
4910 phani.kuma 11722 
        if ftype == TType.MAP:
11723 
          self.pickupDetails = {}
4999 phani.kuma 11724 
          (_ktype211, _vtype212, _size210 ) = iprot.readMapBegin()
11725 
          for _i214 in xrange(_size210):
11726 
            _key215 = iprot.readString();
11727 
            _val216 = iprot.readString();
11728 
            self.pickupDetails[_key215] = _val216
4910 phani.kuma 11729 
          iprot.readMapEnd()
4410 rajveer 11730 
        else:
11731 
          iprot.skip(ftype)
11732 
      else:
11733 
        iprot.skip(ftype)
11734 
      iprot.readFieldEnd()
11735 
    iprot.readStructEnd()
11736 
 
11737 
  def write(self, oprot):
11738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11740 
      return
4910 phani.kuma 11741 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11742 
    if self.providerId is not None:
4910 phani.kuma 11743 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11744 
      oprot.writeI64(self.providerId)
11745 
      oprot.writeFieldEnd()
4910 phani.kuma 11746 
    if self.pickupDetails is not None:
11747 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11748 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4999 phani.kuma 11749 
      for kiter217,viter218 in self.pickupDetails.items():
11750 
        oprot.writeString(kiter217)
11751 
        oprot.writeString(viter218)
4910 phani.kuma 11752 
      oprot.writeMapEnd()
4410 rajveer 11753 
      oprot.writeFieldEnd()
11754 
    oprot.writeFieldStop()
11755 
    oprot.writeStructEnd()
11756 
 
11757 
  def validate(self):
11758 
    return
11759 
 
11760 
 
11761 
  def __repr__(self):
11762 
    L = ['%s=%r' % (key, value)
11763 
      for key, value in self.__dict__.iteritems()]
11764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11765 
 
11766 
  def __eq__(self, other):
11767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11768 
 
11769 
  def __ne__(self, other):
11770 
    return not (self == other)
11771 
 
4910 phani.kuma 11772 
class markOrdersAsPickedUp_result:
4410 rajveer 11773 
  """
11774 
  Attributes:
11775 
   - ex
11776 
  """
11777 
 
11778 
  thrift_spec = (
4910 phani.kuma 11779 
    None, # 0
4410 rajveer 11780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11781 
  )
11782 
 
4910 phani.kuma 11783 
  def __init__(self, ex=None,):
4410 rajveer 11784 
    self.ex = ex
11785 
 
11786 
  def read(self, iprot):
11787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11789 
      return
11790 
    iprot.readStructBegin()
11791 
    while True:
11792 
      (fname, ftype, fid) = iprot.readFieldBegin()
11793 
      if ftype == TType.STOP:
11794 
        break
4910 phani.kuma 11795 
      if fid == 1:
4410 rajveer 11796 
        if ftype == TType.STRUCT:
11797 
          self.ex = TransactionServiceException()
11798 
          self.ex.read(iprot)
11799 
        else:
11800 
          iprot.skip(ftype)
11801 
      else:
11802 
        iprot.skip(ftype)
11803 
      iprot.readFieldEnd()
11804 
    iprot.readStructEnd()
11805 
 
11806 
  def write(self, oprot):
11807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11809 
      return
4910 phani.kuma 11810 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11811 
    if self.ex is not None:
11812 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11813 
      self.ex.write(oprot)
11814 
      oprot.writeFieldEnd()
11815 
    oprot.writeFieldStop()
11816 
    oprot.writeStructEnd()
11817 
 
11818 
  def validate(self):
11819 
    return
11820 
 
11821 
 
11822 
  def __repr__(self):
11823 
    L = ['%s=%r' % (key, value)
11824 
      for key, value in self.__dict__.iteritems()]
11825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11826 
 
11827 
  def __eq__(self, other):
11828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11829 
 
11830 
  def __ne__(self, other):
11831 
    return not (self == other)
11832 
 
4910 phani.kuma 11833 
class getOrdersNotPickedUp_args:
304 ashish 11834 
  """
11835 
  Attributes:
3064 chandransh 11836 
   - providerId
304 ashish 11837 
  """
94 ashish 11838 
 
304 ashish 11839 
  thrift_spec = (
11840 
    None, # 0
3064 chandransh 11841 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 11842 
  )
11843 
 
4910 phani.kuma 11844 
  def __init__(self, providerId=None,):
3064 chandransh 11845 
    self.providerId = providerId
304 ashish 11846 
 
11847 
  def read(self, iprot):
11848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11850 
      return
11851 
    iprot.readStructBegin()
11852 
    while True:
11853 
      (fname, ftype, fid) = iprot.readFieldBegin()
11854 
      if ftype == TType.STOP:
11855 
        break
11856 
      if fid == 1:
11857 
        if ftype == TType.I64:
3064 chandransh 11858 
          self.providerId = iprot.readI64();
304 ashish 11859 
        else:
11860 
          iprot.skip(ftype)
11861 
      else:
11862 
        iprot.skip(ftype)
11863 
      iprot.readFieldEnd()
11864 
    iprot.readStructEnd()
11865 
 
11866 
  def write(self, oprot):
11867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11869 
      return
4910 phani.kuma 11870 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 11871 
    if self.providerId is not None:
3064 chandransh 11872 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11873 
      oprot.writeI64(self.providerId)
304 ashish 11874 
      oprot.writeFieldEnd()
11875 
    oprot.writeFieldStop()
11876 
    oprot.writeStructEnd()
11877 
 
3431 rajveer 11878 
  def validate(self):
11879 
    return
11880 
 
11881 
 
304 ashish 11882 
  def __repr__(self):
11883 
    L = ['%s=%r' % (key, value)
11884 
      for key, value in self.__dict__.iteritems()]
11885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11886 
 
11887 
  def __eq__(self, other):
11888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11889 
 
11890 
  def __ne__(self, other):
11891 
    return not (self == other)
11892 
 
4910 phani.kuma 11893 
class getOrdersNotPickedUp_result:
304 ashish 11894 
  """
11895 
  Attributes:
11896 
   - success
11897 
  """
11898 
 
11899 
  thrift_spec = (
3064 chandransh 11900 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 11901 
  )
11902 
 
4910 phani.kuma 11903 
  def __init__(self, success=None,):
304 ashish 11904 
    self.success = success
11905 
 
11906 
  def read(self, iprot):
11907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11909 
      return
11910 
    iprot.readStructBegin()
11911 
    while True:
11912 
      (fname, ftype, fid) = iprot.readFieldBegin()
11913 
      if ftype == TType.STOP:
11914 
        break
11915 
      if fid == 0:
11916 
        if ftype == TType.LIST:
11917 
          self.success = []
4999 phani.kuma 11918 
          (_etype222, _size219) = iprot.readListBegin()
11919 
          for _i223 in xrange(_size219):
11920 
            _elem224 = Order()
11921 
            _elem224.read(iprot)
11922 
            self.success.append(_elem224)
304 ashish 11923 
          iprot.readListEnd()
11924 
        else:
11925 
          iprot.skip(ftype)
11926 
      else:
11927 
        iprot.skip(ftype)
11928 
      iprot.readFieldEnd()
11929 
    iprot.readStructEnd()
11930 
 
11931 
  def write(self, oprot):
11932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11934 
      return
4910 phani.kuma 11935 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 11936 
    if self.success is not None:
304 ashish 11937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 11939 
      for iter225 in self.success:
11940 
        iter225.write(oprot)
304 ashish 11941 
      oprot.writeListEnd()
11942 
      oprot.writeFieldEnd()
11943 
    oprot.writeFieldStop()
11944 
    oprot.writeStructEnd()
11945 
 
3431 rajveer 11946 
  def validate(self):
11947 
    return
11948 
 
11949 
 
304 ashish 11950 
  def __repr__(self):
11951 
    L = ['%s=%r' % (key, value)
11952 
      for key, value in self.__dict__.iteritems()]
11953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11954 
 
11955 
  def __eq__(self, other):
11956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11957 
 
11958 
  def __ne__(self, other):
11959 
    return not (self == other)
11960 
 
3064 chandransh 11961 
class markOrdersAsDelivered_args:
304 ashish 11962 
  """
11963 
  Attributes:
3064 chandransh 11964 
   - providerId
11965 
   - deliveredOrders
304 ashish 11966 
  """
11967 
 
11968 
  thrift_spec = (
11969 
    None, # 0
3064 chandransh 11970 
    (1, TType.I64, 'providerId', None, None, ), # 1
11971 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11972 
  )
11973 
 
3064 chandransh 11974 
  def __init__(self, providerId=None, deliveredOrders=None,):
11975 
    self.providerId = providerId
11976 
    self.deliveredOrders = deliveredOrders
304 ashish 11977 
 
11978 
  def read(self, iprot):
11979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11981 
      return
11982 
    iprot.readStructBegin()
11983 
    while True:
11984 
      (fname, ftype, fid) = iprot.readFieldBegin()
11985 
      if ftype == TType.STOP:
11986 
        break
11987 
      if fid == 1:
11988 
        if ftype == TType.I64:
3064 chandransh 11989 
          self.providerId = iprot.readI64();
304 ashish 11990 
        else:
11991 
          iprot.skip(ftype)
11992 
      elif fid == 2:
3064 chandransh 11993 
        if ftype == TType.MAP:
11994 
          self.deliveredOrders = {}
4999 phani.kuma 11995 
          (_ktype227, _vtype228, _size226 ) = iprot.readMapBegin()
11996 
          for _i230 in xrange(_size226):
11997 
            _key231 = iprot.readString();
11998 
            _val232 = iprot.readString();
11999 
            self.deliveredOrders[_key231] = _val232
3064 chandransh 12000 
          iprot.readMapEnd()
304 ashish 12001 
        else:
12002 
          iprot.skip(ftype)
12003 
      else:
12004 
        iprot.skip(ftype)
12005 
      iprot.readFieldEnd()
12006 
    iprot.readStructEnd()
12007 
 
12008 
  def write(self, oprot):
12009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12011 
      return
3064 chandransh 12012 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12013 
    if self.providerId is not None:
3064 chandransh 12014 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12015 
      oprot.writeI64(self.providerId)
304 ashish 12016 
      oprot.writeFieldEnd()
3431 rajveer 12017 
    if self.deliveredOrders is not None:
3064 chandransh 12018 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12019 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4999 phani.kuma 12020 
      for kiter233,viter234 in self.deliveredOrders.items():
12021 
        oprot.writeString(kiter233)
12022 
        oprot.writeString(viter234)
3064 chandransh 12023 
      oprot.writeMapEnd()
304 ashish 12024 
      oprot.writeFieldEnd()
12025 
    oprot.writeFieldStop()
12026 
    oprot.writeStructEnd()
12027 
 
3431 rajveer 12028 
  def validate(self):
12029 
    return
12030 
 
12031 
 
304 ashish 12032 
  def __repr__(self):
12033 
    L = ['%s=%r' % (key, value)
12034 
      for key, value in self.__dict__.iteritems()]
12035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12036 
 
12037 
  def __eq__(self, other):
12038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12039 
 
12040 
  def __ne__(self, other):
12041 
    return not (self == other)
12042 
 
3064 chandransh 12043 
class markOrdersAsDelivered_result:
12044 
  """
12045 
  Attributes:
12046 
   - ex
12047 
  """
304 ashish 12048 
 
12049 
  thrift_spec = (
3064 chandransh 12050 
    None, # 0
12051 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12052 
  )
12053 
 
3064 chandransh 12054 
  def __init__(self, ex=None,):
12055 
    self.ex = ex
304 ashish 12056 
 
1596 ankur.sing 12057 
  def read(self, iprot):
12058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12060 
      return
12061 
    iprot.readStructBegin()
12062 
    while True:
12063 
      (fname, ftype, fid) = iprot.readFieldBegin()
12064 
      if ftype == TType.STOP:
12065 
        break
3064 chandransh 12066 
      if fid == 1:
12067 
        if ftype == TType.STRUCT:
12068 
          self.ex = TransactionServiceException()
12069 
          self.ex.read(iprot)
12070 
        else:
12071 
          iprot.skip(ftype)
1596 ankur.sing 12072 
      else:
12073 
        iprot.skip(ftype)
12074 
      iprot.readFieldEnd()
12075 
    iprot.readStructEnd()
12076 
 
12077 
  def write(self, oprot):
12078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12080 
      return
3064 chandransh 12081 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12082 
    if self.ex is not None:
3064 chandransh 12083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12084 
      self.ex.write(oprot)
12085 
      oprot.writeFieldEnd()
1596 ankur.sing 12086 
    oprot.writeFieldStop()
12087 
    oprot.writeStructEnd()
12088 
 
3431 rajveer 12089 
  def validate(self):
12090 
    return
12091 
 
12092 
 
1596 ankur.sing 12093 
  def __repr__(self):
12094 
    L = ['%s=%r' % (key, value)
12095 
      for key, value in self.__dict__.iteritems()]
12096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12097 
 
12098 
  def __eq__(self, other):
12099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12100 
 
12101 
  def __ne__(self, other):
12102 
    return not (self == other)
12103 
 
4910 phani.kuma 12104 
class markAsRTOrders_args:
1596 ankur.sing 12105 
  """
12106 
  Attributes:
3064 chandransh 12107 
   - providerId
12108 
   - returnedOrders
1596 ankur.sing 12109 
  """
12110 
 
12111 
  thrift_spec = (
3064 chandransh 12112 
    None, # 0
12113 
    (1, TType.I64, 'providerId', None, None, ), # 1
12114 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12115 
  )
12116 
 
3064 chandransh 12117 
  def __init__(self, providerId=None, returnedOrders=None,):
12118 
    self.providerId = providerId
12119 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12120 
 
12121 
  def read(self, iprot):
12122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12124 
      return
12125 
    iprot.readStructBegin()
12126 
    while True:
12127 
      (fname, ftype, fid) = iprot.readFieldBegin()
12128 
      if ftype == TType.STOP:
12129 
        break
3064 chandransh 12130 
      if fid == 1:
1596 ankur.sing 12131 
        if ftype == TType.I64:
3064 chandransh 12132 
          self.providerId = iprot.readI64();
1596 ankur.sing 12133 
        else:
12134 
          iprot.skip(ftype)
3064 chandransh 12135 
      elif fid == 2:
12136 
        if ftype == TType.MAP:
12137 
          self.returnedOrders = {}
4999 phani.kuma 12138 
          (_ktype236, _vtype237, _size235 ) = iprot.readMapBegin()
12139 
          for _i239 in xrange(_size235):
12140 
            _key240 = iprot.readString();
12141 
            _val241 = iprot.readString();
12142 
            self.returnedOrders[_key240] = _val241
3064 chandransh 12143 
          iprot.readMapEnd()
12144 
        else:
12145 
          iprot.skip(ftype)
1596 ankur.sing 12146 
      else:
12147 
        iprot.skip(ftype)
12148 
      iprot.readFieldEnd()
12149 
    iprot.readStructEnd()
12150 
 
12151 
  def write(self, oprot):
12152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12154 
      return
4910 phani.kuma 12155 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12156 
    if self.providerId is not None:
3064 chandransh 12157 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12158 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12159 
      oprot.writeFieldEnd()
3431 rajveer 12160 
    if self.returnedOrders is not None:
3064 chandransh 12161 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12162 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4999 phani.kuma 12163 
      for kiter242,viter243 in self.returnedOrders.items():
12164 
        oprot.writeString(kiter242)
12165 
        oprot.writeString(viter243)
3064 chandransh 12166 
      oprot.writeMapEnd()
12167 
      oprot.writeFieldEnd()
1596 ankur.sing 12168 
    oprot.writeFieldStop()
12169 
    oprot.writeStructEnd()
12170 
 
3431 rajveer 12171 
  def validate(self):
12172 
    return
12173 
 
12174 
 
1596 ankur.sing 12175 
  def __repr__(self):
12176 
    L = ['%s=%r' % (key, value)
12177 
      for key, value in self.__dict__.iteritems()]
12178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12179 
 
12180 
  def __eq__(self, other):
12181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12182 
 
12183 
  def __ne__(self, other):
12184 
    return not (self == other)
12185 
 
4910 phani.kuma 12186 
class markAsRTOrders_result:
3064 chandransh 12187 
  """
12188 
  Attributes:
12189 
   - ex
12190 
  """
1596 ankur.sing 12191 
 
1627 ankur.sing 12192 
  thrift_spec = (
3064 chandransh 12193 
    None, # 0
12194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12195 
  )
12196 
 
3064 chandransh 12197 
  def __init__(self, ex=None,):
12198 
    self.ex = ex
12199 
 
1627 ankur.sing 12200 
  def read(self, iprot):
12201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12203 
      return
12204 
    iprot.readStructBegin()
12205 
    while True:
12206 
      (fname, ftype, fid) = iprot.readFieldBegin()
12207 
      if ftype == TType.STOP:
12208 
        break
3064 chandransh 12209 
      if fid == 1:
12210 
        if ftype == TType.STRUCT:
12211 
          self.ex = TransactionServiceException()
12212 
          self.ex.read(iprot)
12213 
        else:
12214 
          iprot.skip(ftype)
1627 ankur.sing 12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
4910 phani.kuma 12224 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12225 
    if self.ex is not None:
3064 chandransh 12226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12227 
      self.ex.write(oprot)
12228 
      oprot.writeFieldEnd()
1627 ankur.sing 12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
3431 rajveer 12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
1627 ankur.sing 12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
4910 phani.kuma 12247 
class getRTOrders_args:
12248 
  """
12249 
  Attributes:
12250 
   - providerId
12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    None, # 0
12255 
    (1, TType.I64, 'providerId', None, None, ), # 1
12256 
  )
12257 
 
12258 
  def __init__(self, providerId=None,):
12259 
    self.providerId = providerId
12260 
 
12261 
  def read(self, iprot):
12262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12264 
      return
12265 
    iprot.readStructBegin()
12266 
    while True:
12267 
      (fname, ftype, fid) = iprot.readFieldBegin()
12268 
      if ftype == TType.STOP:
12269 
        break
12270 
      if fid == 1:
12271 
        if ftype == TType.I64:
12272 
          self.providerId = iprot.readI64();
12273 
        else:
12274 
          iprot.skip(ftype)
12275 
      else:
12276 
        iprot.skip(ftype)
12277 
      iprot.readFieldEnd()
12278 
    iprot.readStructEnd()
12279 
 
12280 
  def write(self, oprot):
12281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12283 
      return
12284 
    oprot.writeStructBegin('getRTOrders_args')
12285 
    if self.providerId is not None:
12286 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12287 
      oprot.writeI64(self.providerId)
12288 
      oprot.writeFieldEnd()
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
12307 
class getRTOrders_result:
12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
  """
12312 
 
12313 
  thrift_spec = (
12314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12315 
  )
12316 
 
12317 
  def __init__(self, success=None,):
12318 
    self.success = success
12319 
 
12320 
  def read(self, iprot):
12321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12323 
      return
12324 
    iprot.readStructBegin()
12325 
    while True:
12326 
      (fname, ftype, fid) = iprot.readFieldBegin()
12327 
      if ftype == TType.STOP:
12328 
        break
12329 
      if fid == 0:
12330 
        if ftype == TType.LIST:
12331 
          self.success = []
4999 phani.kuma 12332 
          (_etype247, _size244) = iprot.readListBegin()
12333 
          for _i248 in xrange(_size244):
12334 
            _elem249 = Order()
12335 
            _elem249.read(iprot)
12336 
            self.success.append(_elem249)
4910 phani.kuma 12337 
          iprot.readListEnd()
12338 
        else:
12339 
          iprot.skip(ftype)
12340 
      else:
12341 
        iprot.skip(ftype)
12342 
      iprot.readFieldEnd()
12343 
    iprot.readStructEnd()
12344 
 
12345 
  def write(self, oprot):
12346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12348 
      return
12349 
    oprot.writeStructBegin('getRTOrders_result')
12350 
    if self.success is not None:
12351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 12353 
      for iter250 in self.success:
12354 
        iter250.write(oprot)
4910 phani.kuma 12355 
      oprot.writeListEnd()
12356 
      oprot.writeFieldEnd()
12357 
    oprot.writeFieldStop()
12358 
    oprot.writeStructEnd()
12359 
 
12360 
  def validate(self):
12361 
    return
12362 
 
12363 
 
12364 
  def __repr__(self):
12365 
    L = ['%s=%r' % (key, value)
12366 
      for key, value in self.__dict__.iteritems()]
12367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12368 
 
12369 
  def __eq__(self, other):
12370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12371 
 
12372 
  def __ne__(self, other):
12373 
    return not (self == other)
12374 
 
3064 chandransh 12375 
class updateNonDeliveryReason_args:
1627 ankur.sing 12376 
  """
12377 
  Attributes:
3064 chandransh 12378 
   - providerId
12379 
   - undeliveredOrders
1627 ankur.sing 12380 
  """
12381 
 
12382 
  thrift_spec = (
3064 chandransh 12383 
    None, # 0
12384 
    (1, TType.I64, 'providerId', None, None, ), # 1
12385 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12386 
  )
12387 
 
3064 chandransh 12388 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12389 
    self.providerId = providerId
12390 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12391 
 
12392 
  def read(self, iprot):
12393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12395 
      return
12396 
    iprot.readStructBegin()
12397 
    while True:
12398 
      (fname, ftype, fid) = iprot.readFieldBegin()
12399 
      if ftype == TType.STOP:
12400 
        break
3064 chandransh 12401 
      if fid == 1:
1627 ankur.sing 12402 
        if ftype == TType.I64:
3064 chandransh 12403 
          self.providerId = iprot.readI64();
1627 ankur.sing 12404 
        else:
12405 
          iprot.skip(ftype)
3064 chandransh 12406 
      elif fid == 2:
12407 
        if ftype == TType.MAP:
12408 
          self.undeliveredOrders = {}
4999 phani.kuma 12409 
          (_ktype252, _vtype253, _size251 ) = iprot.readMapBegin()
12410 
          for _i255 in xrange(_size251):
12411 
            _key256 = iprot.readString();
12412 
            _val257 = iprot.readString();
12413 
            self.undeliveredOrders[_key256] = _val257
3064 chandransh 12414 
          iprot.readMapEnd()
12415 
        else:
12416 
          iprot.skip(ftype)
1627 ankur.sing 12417 
      else:
12418 
        iprot.skip(ftype)
12419 
      iprot.readFieldEnd()
12420 
    iprot.readStructEnd()
12421 
 
12422 
  def write(self, oprot):
12423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12425 
      return
3064 chandransh 12426 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12427 
    if self.providerId is not None:
3064 chandransh 12428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12429 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12430 
      oprot.writeFieldEnd()
3431 rajveer 12431 
    if self.undeliveredOrders is not None:
3064 chandransh 12432 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12433 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4999 phani.kuma 12434 
      for kiter258,viter259 in self.undeliveredOrders.items():
12435 
        oprot.writeString(kiter258)
12436 
        oprot.writeString(viter259)
3064 chandransh 12437 
      oprot.writeMapEnd()
12438 
      oprot.writeFieldEnd()
1627 ankur.sing 12439 
    oprot.writeFieldStop()
12440 
    oprot.writeStructEnd()
12441 
 
3431 rajveer 12442 
  def validate(self):
12443 
    return
12444 
 
12445 
 
1627 ankur.sing 12446 
  def __repr__(self):
12447 
    L = ['%s=%r' % (key, value)
12448 
      for key, value in self.__dict__.iteritems()]
12449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12450 
 
12451 
  def __eq__(self, other):
12452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12453 
 
12454 
  def __ne__(self, other):
12455 
    return not (self == other)
12456 
 
3064 chandransh 12457 
class updateNonDeliveryReason_result:
1627 ankur.sing 12458 
  """
12459 
  Attributes:
3064 chandransh 12460 
   - ex
1627 ankur.sing 12461 
  """
12462 
 
12463 
  thrift_spec = (
4910 phani.kuma 12464 
    None, # 0
3064 chandransh 12465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12466 
  )
12467 
 
4910 phani.kuma 12468 
  def __init__(self, ex=None,):
3064 chandransh 12469 
    self.ex = ex
1627 ankur.sing 12470 
 
12471 
  def read(self, iprot):
12472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12474 
      return
12475 
    iprot.readStructBegin()
12476 
    while True:
12477 
      (fname, ftype, fid) = iprot.readFieldBegin()
12478 
      if ftype == TType.STOP:
12479 
        break
4910 phani.kuma 12480 
      if fid == 1:
12481 
        if ftype == TType.STRUCT:
12482 
          self.ex = TransactionServiceException()
12483 
          self.ex.read(iprot)
12484 
        else:
12485 
          iprot.skip(ftype)
12486 
      else:
12487 
        iprot.skip(ftype)
12488 
      iprot.readFieldEnd()
12489 
    iprot.readStructEnd()
12490 
 
12491 
  def write(self, oprot):
12492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12494 
      return
12495 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12496 
    if self.ex is not None:
12497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12498 
      self.ex.write(oprot)
12499 
      oprot.writeFieldEnd()
12500 
    oprot.writeFieldStop()
12501 
    oprot.writeStructEnd()
12502 
 
12503 
  def validate(self):
12504 
    return
12505 
 
12506 
 
12507 
  def __repr__(self):
12508 
    L = ['%s=%r' % (key, value)
12509 
      for key, value in self.__dict__.iteritems()]
12510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12511 
 
12512 
  def __eq__(self, other):
12513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12514 
 
12515 
  def __ne__(self, other):
12516 
    return not (self == other)
12517 
 
12518 
class getNonDeliveredOrdersbyCourier_args:
12519 
  """
12520 
  Attributes:
12521 
   - providerId
12522 
  """
12523 
 
12524 
  thrift_spec = (
12525 
    None, # 0
12526 
    (1, TType.I64, 'providerId', None, None, ), # 1
12527 
  )
12528 
 
12529 
  def __init__(self, providerId=None,):
12530 
    self.providerId = providerId
12531 
 
12532 
  def read(self, iprot):
12533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12535 
      return
12536 
    iprot.readStructBegin()
12537 
    while True:
12538 
      (fname, ftype, fid) = iprot.readFieldBegin()
12539 
      if ftype == TType.STOP:
12540 
        break
12541 
      if fid == 1:
12542 
        if ftype == TType.I64:
12543 
          self.providerId = iprot.readI64();
12544 
        else:
12545 
          iprot.skip(ftype)
12546 
      else:
12547 
        iprot.skip(ftype)
12548 
      iprot.readFieldEnd()
12549 
    iprot.readStructEnd()
12550 
 
12551 
  def write(self, oprot):
12552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12554 
      return
12555 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12556 
    if self.providerId is not None:
12557 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12558 
      oprot.writeI64(self.providerId)
12559 
      oprot.writeFieldEnd()
12560 
    oprot.writeFieldStop()
12561 
    oprot.writeStructEnd()
12562 
 
12563 
  def validate(self):
12564 
    return
12565 
 
12566 
 
12567 
  def __repr__(self):
12568 
    L = ['%s=%r' % (key, value)
12569 
      for key, value in self.__dict__.iteritems()]
12570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12571 
 
12572 
  def __eq__(self, other):
12573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12574 
 
12575 
  def __ne__(self, other):
12576 
    return not (self == other)
12577 
 
12578 
class getNonDeliveredOrdersbyCourier_result:
12579 
  """
12580 
  Attributes:
12581 
   - success
12582 
  """
12583 
 
12584 
  thrift_spec = (
12585 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12586 
  )
12587 
 
12588 
  def __init__(self, success=None,):
12589 
    self.success = success
12590 
 
12591 
  def read(self, iprot):
12592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12594 
      return
12595 
    iprot.readStructBegin()
12596 
    while True:
12597 
      (fname, ftype, fid) = iprot.readFieldBegin()
12598 
      if ftype == TType.STOP:
12599 
        break
4581 phani.kuma 12600 
      if fid == 0:
12601 
        if ftype == TType.LIST:
12602 
          self.success = []
4999 phani.kuma 12603 
          (_etype263, _size260) = iprot.readListBegin()
12604 
          for _i264 in xrange(_size260):
12605 
            _elem265 = Order()
12606 
            _elem265.read(iprot)
12607 
            self.success.append(_elem265)
4581 phani.kuma 12608 
          iprot.readListEnd()
12609 
        else:
12610 
          iprot.skip(ftype)
4910 phani.kuma 12611 
      else:
12612 
        iprot.skip(ftype)
12613 
      iprot.readFieldEnd()
12614 
    iprot.readStructEnd()
12615 
 
12616 
  def write(self, oprot):
12617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12619 
      return
12620 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12621 
    if self.success is not None:
12622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 12624 
      for iter266 in self.success:
12625 
        iter266.write(oprot)
4910 phani.kuma 12626 
      oprot.writeListEnd()
12627 
      oprot.writeFieldEnd()
12628 
    oprot.writeFieldStop()
12629 
    oprot.writeStructEnd()
12630 
 
12631 
  def validate(self):
12632 
    return
12633 
 
12634 
 
12635 
  def __repr__(self):
12636 
    L = ['%s=%r' % (key, value)
12637 
      for key, value in self.__dict__.iteritems()]
12638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12639 
 
12640 
  def __eq__(self, other):
12641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12642 
 
12643 
  def __ne__(self, other):
12644 
    return not (self == other)
12645 
 
12646 
class markOrdersAsLocalConnected_args:
12647 
  """
12648 
  Attributes:
12649 
   - providerId
12650 
   - local_connected_orders
12651 
  """
12652 
 
12653 
  thrift_spec = (
12654 
    None, # 0
12655 
    (1, TType.I64, 'providerId', None, None, ), # 1
12656 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12657 
  )
12658 
 
12659 
  def __init__(self, providerId=None, local_connected_orders=None,):
12660 
    self.providerId = providerId
12661 
    self.local_connected_orders = local_connected_orders
12662 
 
12663 
  def read(self, iprot):
12664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12666 
      return
12667 
    iprot.readStructBegin()
12668 
    while True:
12669 
      (fname, ftype, fid) = iprot.readFieldBegin()
12670 
      if ftype == TType.STOP:
12671 
        break
12672 
      if fid == 1:
12673 
        if ftype == TType.I64:
12674 
          self.providerId = iprot.readI64();
12675 
        else:
12676 
          iprot.skip(ftype)
12677 
      elif fid == 2:
12678 
        if ftype == TType.MAP:
12679 
          self.local_connected_orders = {}
4999 phani.kuma 12680 
          (_ktype268, _vtype269, _size267 ) = iprot.readMapBegin()
12681 
          for _i271 in xrange(_size267):
12682 
            _key272 = iprot.readString();
12683 
            _val273 = iprot.readString();
12684 
            self.local_connected_orders[_key272] = _val273
4910 phani.kuma 12685 
          iprot.readMapEnd()
12686 
        else:
12687 
          iprot.skip(ftype)
12688 
      else:
12689 
        iprot.skip(ftype)
12690 
      iprot.readFieldEnd()
12691 
    iprot.readStructEnd()
12692 
 
12693 
  def write(self, oprot):
12694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12696 
      return
12697 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12698 
    if self.providerId is not None:
12699 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12700 
      oprot.writeI64(self.providerId)
12701 
      oprot.writeFieldEnd()
12702 
    if self.local_connected_orders is not None:
12703 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12704 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
4999 phani.kuma 12705 
      for kiter274,viter275 in self.local_connected_orders.items():
12706 
        oprot.writeString(kiter274)
12707 
        oprot.writeString(viter275)
4910 phani.kuma 12708 
      oprot.writeMapEnd()
12709 
      oprot.writeFieldEnd()
12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class markOrdersAsLocalConnected_result:
12729 
  """
12730 
  Attributes:
12731 
   - ex
12732 
  """
12733 
 
12734 
  thrift_spec = (
12735 
    None, # 0
12736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12737 
  )
12738 
 
12739 
  def __init__(self, ex=None,):
12740 
    self.ex = ex
12741 
 
12742 
  def read(self, iprot):
12743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12745 
      return
12746 
    iprot.readStructBegin()
12747 
    while True:
12748 
      (fname, ftype, fid) = iprot.readFieldBegin()
12749 
      if ftype == TType.STOP:
12750 
        break
12751 
      if fid == 1:
3064 chandransh 12752 
        if ftype == TType.STRUCT:
12753 
          self.ex = TransactionServiceException()
12754 
          self.ex.read(iprot)
1627 ankur.sing 12755 
        else:
12756 
          iprot.skip(ftype)
12757 
      else:
12758 
        iprot.skip(ftype)
12759 
      iprot.readFieldEnd()
12760 
    iprot.readStructEnd()
12761 
 
12762 
  def write(self, oprot):
12763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12765 
      return
4910 phani.kuma 12766 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12767 
    if self.ex is not None:
12768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12769 
      self.ex.write(oprot)
12770 
      oprot.writeFieldEnd()
12771 
    oprot.writeFieldStop()
12772 
    oprot.writeStructEnd()
12773 
 
12774 
  def validate(self):
12775 
    return
12776 
 
12777 
 
12778 
  def __repr__(self):
12779 
    L = ['%s=%r' % (key, value)
12780 
      for key, value in self.__dict__.iteritems()]
12781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12782 
 
12783 
  def __eq__(self, other):
12784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12785 
 
12786 
  def __ne__(self, other):
12787 
    return not (self == other)
12788 
 
12789 
class getOrdersNotLocalConnected_args:
12790 
  """
12791 
  Attributes:
12792 
   - providerId
12793 
  """
12794 
 
12795 
  thrift_spec = (
12796 
    None, # 0
12797 
    (1, TType.I64, 'providerId', None, None, ), # 1
12798 
  )
12799 
 
12800 
  def __init__(self, providerId=None,):
12801 
    self.providerId = providerId
12802 
 
12803 
  def read(self, iprot):
12804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12806 
      return
12807 
    iprot.readStructBegin()
12808 
    while True:
12809 
      (fname, ftype, fid) = iprot.readFieldBegin()
12810 
      if ftype == TType.STOP:
12811 
        break
12812 
      if fid == 1:
12813 
        if ftype == TType.I64:
12814 
          self.providerId = iprot.readI64();
12815 
        else:
12816 
          iprot.skip(ftype)
12817 
      else:
12818 
        iprot.skip(ftype)
12819 
      iprot.readFieldEnd()
12820 
    iprot.readStructEnd()
12821 
 
12822 
  def write(self, oprot):
12823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12825 
      return
12826 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12827 
    if self.providerId is not None:
12828 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12829 
      oprot.writeI64(self.providerId)
12830 
      oprot.writeFieldEnd()
12831 
    oprot.writeFieldStop()
12832 
    oprot.writeStructEnd()
12833 
 
12834 
  def validate(self):
12835 
    return
12836 
 
12837 
 
12838 
  def __repr__(self):
12839 
    L = ['%s=%r' % (key, value)
12840 
      for key, value in self.__dict__.iteritems()]
12841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12842 
 
12843 
  def __eq__(self, other):
12844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12845 
 
12846 
  def __ne__(self, other):
12847 
    return not (self == other)
12848 
 
12849 
class getOrdersNotLocalConnected_result:
12850 
  """
12851 
  Attributes:
12852 
   - success
12853 
  """
12854 
 
12855 
  thrift_spec = (
12856 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12857 
  )
12858 
 
12859 
  def __init__(self, success=None,):
12860 
    self.success = success
12861 
 
12862 
  def read(self, iprot):
12863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12865 
      return
12866 
    iprot.readStructBegin()
12867 
    while True:
12868 
      (fname, ftype, fid) = iprot.readFieldBegin()
12869 
      if ftype == TType.STOP:
12870 
        break
12871 
      if fid == 0:
12872 
        if ftype == TType.LIST:
12873 
          self.success = []
4999 phani.kuma 12874 
          (_etype279, _size276) = iprot.readListBegin()
12875 
          for _i280 in xrange(_size276):
12876 
            _elem281 = Order()
12877 
            _elem281.read(iprot)
12878 
            self.success.append(_elem281)
4910 phani.kuma 12879 
          iprot.readListEnd()
12880 
        else:
12881 
          iprot.skip(ftype)
12882 
      else:
12883 
        iprot.skip(ftype)
12884 
      iprot.readFieldEnd()
12885 
    iprot.readStructEnd()
12886 
 
12887 
  def write(self, oprot):
12888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12890 
      return
12891 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 12892 
    if self.success is not None:
12893 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12894 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 12895 
      for iter282 in self.success:
12896 
        iter282.write(oprot)
4581 phani.kuma 12897 
      oprot.writeListEnd()
12898 
      oprot.writeFieldEnd()
4910 phani.kuma 12899 
    oprot.writeFieldStop()
12900 
    oprot.writeStructEnd()
12901 
 
12902 
  def validate(self):
12903 
    return
12904 
 
12905 
 
12906 
  def __repr__(self):
12907 
    L = ['%s=%r' % (key, value)
12908 
      for key, value in self.__dict__.iteritems()]
12909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12910 
 
12911 
  def __eq__(self, other):
12912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12913 
 
12914 
  def __ne__(self, other):
12915 
    return not (self == other)
12916 
 
12917 
class markOrdersAsDestinationCityReached_args:
12918 
  """
12919 
  Attributes:
12920 
   - providerId
12921 
   - destination_city_reached_orders
12922 
  """
12923 
 
12924 
  thrift_spec = (
12925 
    None, # 0
12926 
    (1, TType.I64, 'providerId', None, None, ), # 1
12927 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12928 
  )
12929 
 
12930 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
12931 
    self.providerId = providerId
12932 
    self.destination_city_reached_orders = destination_city_reached_orders
12933 
 
12934 
  def read(self, iprot):
12935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12937 
      return
12938 
    iprot.readStructBegin()
12939 
    while True:
12940 
      (fname, ftype, fid) = iprot.readFieldBegin()
12941 
      if ftype == TType.STOP:
12942 
        break
12943 
      if fid == 1:
12944 
        if ftype == TType.I64:
12945 
          self.providerId = iprot.readI64();
12946 
        else:
12947 
          iprot.skip(ftype)
12948 
      elif fid == 2:
12949 
        if ftype == TType.MAP:
12950 
          self.destination_city_reached_orders = {}
4999 phani.kuma 12951 
          (_ktype284, _vtype285, _size283 ) = iprot.readMapBegin()
12952 
          for _i287 in xrange(_size283):
12953 
            _key288 = iprot.readString();
12954 
            _val289 = iprot.readString();
12955 
            self.destination_city_reached_orders[_key288] = _val289
4910 phani.kuma 12956 
          iprot.readMapEnd()
12957 
        else:
12958 
          iprot.skip(ftype)
12959 
      else:
12960 
        iprot.skip(ftype)
12961 
      iprot.readFieldEnd()
12962 
    iprot.readStructEnd()
12963 
 
12964 
  def write(self, oprot):
12965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12967 
      return
12968 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
12969 
    if self.providerId is not None:
12970 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12971 
      oprot.writeI64(self.providerId)
12972 
      oprot.writeFieldEnd()
12973 
    if self.destination_city_reached_orders is not None:
12974 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
12975 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
4999 phani.kuma 12976 
      for kiter290,viter291 in self.destination_city_reached_orders.items():
12977 
        oprot.writeString(kiter290)
12978 
        oprot.writeString(viter291)
4910 phani.kuma 12979 
      oprot.writeMapEnd()
12980 
      oprot.writeFieldEnd()
12981 
    oprot.writeFieldStop()
12982 
    oprot.writeStructEnd()
12983 
 
12984 
  def validate(self):
12985 
    return
12986 
 
12987 
 
12988 
  def __repr__(self):
12989 
    L = ['%s=%r' % (key, value)
12990 
      for key, value in self.__dict__.iteritems()]
12991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12992 
 
12993 
  def __eq__(self, other):
12994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12995 
 
12996 
  def __ne__(self, other):
12997 
    return not (self == other)
12998 
 
12999 
class markOrdersAsDestinationCityReached_result:
13000 
  """
13001 
  Attributes:
13002 
   - ex
13003 
  """
13004 
 
13005 
  thrift_spec = (
13006 
    None, # 0
13007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13008 
  )
13009 
 
13010 
  def __init__(self, ex=None,):
13011 
    self.ex = ex
13012 
 
13013 
  def read(self, iprot):
13014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13016 
      return
13017 
    iprot.readStructBegin()
13018 
    while True:
13019 
      (fname, ftype, fid) = iprot.readFieldBegin()
13020 
      if ftype == TType.STOP:
13021 
        break
13022 
      if fid == 1:
13023 
        if ftype == TType.STRUCT:
13024 
          self.ex = TransactionServiceException()
13025 
          self.ex.read(iprot)
13026 
        else:
13027 
          iprot.skip(ftype)
13028 
      else:
13029 
        iprot.skip(ftype)
13030 
      iprot.readFieldEnd()
13031 
    iprot.readStructEnd()
13032 
 
13033 
  def write(self, oprot):
13034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13036 
      return
13037 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13038 
    if self.ex is not None:
3064 chandransh 13039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13040 
      self.ex.write(oprot)
1627 ankur.sing 13041 
      oprot.writeFieldEnd()
13042 
    oprot.writeFieldStop()
13043 
    oprot.writeStructEnd()
13044 
 
3431 rajveer 13045 
  def validate(self):
13046 
    return
13047 
 
13048 
 
1627 ankur.sing 13049 
  def __repr__(self):
13050 
    L = ['%s=%r' % (key, value)
13051 
      for key, value in self.__dict__.iteritems()]
13052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13053 
 
13054 
  def __eq__(self, other):
13055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13056 
 
13057 
  def __ne__(self, other):
13058 
    return not (self == other)
13059 
 
4910 phani.kuma 13060 
class markOrdersAsFirstDeliveryAttempted_args:
13061 
  """
13062 
  Attributes:
13063 
   - providerId
13064 
   - first_atdl_orders
13065 
  """
13066 
 
13067 
  thrift_spec = (
13068 
    None, # 0
13069 
    (1, TType.I64, 'providerId', None, None, ), # 1
13070 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13071 
  )
13072 
 
13073 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13074 
    self.providerId = providerId
13075 
    self.first_atdl_orders = first_atdl_orders
13076 
 
13077 
  def read(self, iprot):
13078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13080 
      return
13081 
    iprot.readStructBegin()
13082 
    while True:
13083 
      (fname, ftype, fid) = iprot.readFieldBegin()
13084 
      if ftype == TType.STOP:
13085 
        break
13086 
      if fid == 1:
13087 
        if ftype == TType.I64:
13088 
          self.providerId = iprot.readI64();
13089 
        else:
13090 
          iprot.skip(ftype)
13091 
      elif fid == 2:
13092 
        if ftype == TType.MAP:
13093 
          self.first_atdl_orders = {}
4999 phani.kuma 13094 
          (_ktype293, _vtype294, _size292 ) = iprot.readMapBegin()
13095 
          for _i296 in xrange(_size292):
13096 
            _key297 = iprot.readString();
13097 
            _val298 = iprot.readString();
13098 
            self.first_atdl_orders[_key297] = _val298
4910 phani.kuma 13099 
          iprot.readMapEnd()
13100 
        else:
13101 
          iprot.skip(ftype)
13102 
      else:
13103 
        iprot.skip(ftype)
13104 
      iprot.readFieldEnd()
13105 
    iprot.readStructEnd()
13106 
 
13107 
  def write(self, oprot):
13108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13110 
      return
13111 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13112 
    if self.providerId is not None:
13113 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13114 
      oprot.writeI64(self.providerId)
13115 
      oprot.writeFieldEnd()
13116 
    if self.first_atdl_orders is not None:
13117 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13118 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
4999 phani.kuma 13119 
      for kiter299,viter300 in self.first_atdl_orders.items():
13120 
        oprot.writeString(kiter299)
13121 
        oprot.writeString(viter300)
4910 phani.kuma 13122 
      oprot.writeMapEnd()
13123 
      oprot.writeFieldEnd()
13124 
    oprot.writeFieldStop()
13125 
    oprot.writeStructEnd()
13126 
 
13127 
  def validate(self):
13128 
    return
13129 
 
13130 
 
13131 
  def __repr__(self):
13132 
    L = ['%s=%r' % (key, value)
13133 
      for key, value in self.__dict__.iteritems()]
13134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13135 
 
13136 
  def __eq__(self, other):
13137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13138 
 
13139 
  def __ne__(self, other):
13140 
    return not (self == other)
13141 
 
13142 
class markOrdersAsFirstDeliveryAttempted_result:
13143 
  """
13144 
  Attributes:
13145 
   - ex
13146 
  """
13147 
 
13148 
  thrift_spec = (
13149 
    None, # 0
13150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13151 
  )
13152 
 
13153 
  def __init__(self, ex=None,):
13154 
    self.ex = ex
13155 
 
13156 
  def read(self, iprot):
13157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13159 
      return
13160 
    iprot.readStructBegin()
13161 
    while True:
13162 
      (fname, ftype, fid) = iprot.readFieldBegin()
13163 
      if ftype == TType.STOP:
13164 
        break
13165 
      if fid == 1:
13166 
        if ftype == TType.STRUCT:
13167 
          self.ex = TransactionServiceException()
13168 
          self.ex.read(iprot)
13169 
        else:
13170 
          iprot.skip(ftype)
13171 
      else:
13172 
        iprot.skip(ftype)
13173 
      iprot.readFieldEnd()
13174 
    iprot.readStructEnd()
13175 
 
13176 
  def write(self, oprot):
13177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13179 
      return
13180 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13181 
    if self.ex is not None:
13182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13183 
      self.ex.write(oprot)
13184 
      oprot.writeFieldEnd()
13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
3064 chandransh 13203 
class getUndeliveredOrders_args:
1886 ankur.sing 13204 
  """
13205 
  Attributes:
3064 chandransh 13206 
   - providerId
13207 
   - warehouseId
1886 ankur.sing 13208 
  """
1627 ankur.sing 13209 
 
1886 ankur.sing 13210 
  thrift_spec = (
13211 
    None, # 0
3064 chandransh 13212 
    (1, TType.I64, 'providerId', None, None, ), # 1
13213 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13214 
  )
13215 
 
3064 chandransh 13216 
  def __init__(self, providerId=None, warehouseId=None,):
13217 
    self.providerId = providerId
13218 
    self.warehouseId = warehouseId
1886 ankur.sing 13219 
 
13220 
  def read(self, iprot):
13221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13223 
      return
13224 
    iprot.readStructBegin()
13225 
    while True:
13226 
      (fname, ftype, fid) = iprot.readFieldBegin()
13227 
      if ftype == TType.STOP:
13228 
        break
13229 
      if fid == 1:
13230 
        if ftype == TType.I64:
3064 chandransh 13231 
          self.providerId = iprot.readI64();
1886 ankur.sing 13232 
        else:
13233 
          iprot.skip(ftype)
3064 chandransh 13234 
      elif fid == 2:
13235 
        if ftype == TType.I64:
13236 
          self.warehouseId = iprot.readI64();
13237 
        else:
13238 
          iprot.skip(ftype)
1886 ankur.sing 13239 
      else:
13240 
        iprot.skip(ftype)
13241 
      iprot.readFieldEnd()
13242 
    iprot.readStructEnd()
13243 
 
13244 
  def write(self, oprot):
13245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13247 
      return
3064 chandransh 13248 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13249 
    if self.providerId is not None:
3064 chandransh 13250 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13251 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13252 
      oprot.writeFieldEnd()
3431 rajveer 13253 
    if self.warehouseId is not None:
3064 chandransh 13254 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13255 
      oprot.writeI64(self.warehouseId)
13256 
      oprot.writeFieldEnd()
1886 ankur.sing 13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
3431 rajveer 13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
1886 ankur.sing 13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
3064 chandransh 13275 
class getUndeliveredOrders_result:
1886 ankur.sing 13276 
  """
13277 
  Attributes:
13278 
   - success
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13283 
  )
13284 
 
13285 
  def __init__(self, success=None,):
13286 
    self.success = success
13287 
 
13288 
  def read(self, iprot):
13289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13291 
      return
13292 
    iprot.readStructBegin()
13293 
    while True:
13294 
      (fname, ftype, fid) = iprot.readFieldBegin()
13295 
      if ftype == TType.STOP:
13296 
        break
13297 
      if fid == 0:
13298 
        if ftype == TType.LIST:
13299 
          self.success = []
4999 phani.kuma 13300 
          (_etype304, _size301) = iprot.readListBegin()
13301 
          for _i305 in xrange(_size301):
13302 
            _elem306 = Order()
13303 
            _elem306.read(iprot)
13304 
            self.success.append(_elem306)
1886 ankur.sing 13305 
          iprot.readListEnd()
13306 
        else:
13307 
          iprot.skip(ftype)
13308 
      else:
13309 
        iprot.skip(ftype)
13310 
      iprot.readFieldEnd()
13311 
    iprot.readStructEnd()
13312 
 
13313 
  def write(self, oprot):
13314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13316 
      return
3064 chandransh 13317 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13318 
    if self.success is not None:
1886 ankur.sing 13319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 13321 
      for iter307 in self.success:
13322 
        iter307.write(oprot)
1886 ankur.sing 13323 
      oprot.writeListEnd()
13324 
      oprot.writeFieldEnd()
13325 
    oprot.writeFieldStop()
13326 
    oprot.writeStructEnd()
13327 
 
3431 rajveer 13328 
  def validate(self):
13329 
    return
13330 
 
13331 
 
1886 ankur.sing 13332 
  def __repr__(self):
13333 
    L = ['%s=%r' % (key, value)
13334 
      for key, value in self.__dict__.iteritems()]
13335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13336 
 
13337 
  def __eq__(self, other):
13338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13339 
 
13340 
  def __ne__(self, other):
13341 
    return not (self == other)
13342 
 
4783 phani.kuma 13343 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13344 
 
13345 
  thrift_spec = (
13346 
  )
13347 
 
13348 
  def read(self, iprot):
13349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13351 
      return
13352 
    iprot.readStructBegin()
13353 
    while True:
13354 
      (fname, ftype, fid) = iprot.readFieldBegin()
13355 
      if ftype == TType.STOP:
13356 
        break
13357 
      else:
13358 
        iprot.skip(ftype)
13359 
      iprot.readFieldEnd()
13360 
    iprot.readStructEnd()
13361 
 
13362 
  def write(self, oprot):
13363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13365 
      return
13366 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13367 
    oprot.writeFieldStop()
13368 
    oprot.writeStructEnd()
13369 
 
13370 
  def validate(self):
13371 
    return
13372 
 
13373 
 
13374 
  def __repr__(self):
13375 
    L = ['%s=%r' % (key, value)
13376 
      for key, value in self.__dict__.iteritems()]
13377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13378 
 
13379 
  def __eq__(self, other):
13380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13381 
 
13382 
  def __ne__(self, other):
13383 
    return not (self == other)
13384 
 
13385 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13386 
  """
13387 
  Attributes:
13388 
   - success
13389 
  """
13390 
 
13391 
  thrift_spec = (
13392 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13393 
  )
13394 
 
13395 
  def __init__(self, success=None,):
13396 
    self.success = success
13397 
 
13398 
  def read(self, iprot):
13399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13401 
      return
13402 
    iprot.readStructBegin()
13403 
    while True:
13404 
      (fname, ftype, fid) = iprot.readFieldBegin()
13405 
      if ftype == TType.STOP:
13406 
        break
13407 
      if fid == 0:
13408 
        if ftype == TType.LIST:
13409 
          self.success = []
4999 phani.kuma 13410 
          (_etype311, _size308) = iprot.readListBegin()
13411 
          for _i312 in xrange(_size308):
13412 
            _elem313 = Order()
13413 
            _elem313.read(iprot)
13414 
            self.success.append(_elem313)
4783 phani.kuma 13415 
          iprot.readListEnd()
13416 
        else:
13417 
          iprot.skip(ftype)
13418 
      else:
13419 
        iprot.skip(ftype)
13420 
      iprot.readFieldEnd()
13421 
    iprot.readStructEnd()
13422 
 
13423 
  def write(self, oprot):
13424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13426 
      return
13427 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13428 
    if self.success is not None:
13429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13430 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 13431 
      for iter314 in self.success:
13432 
        iter314.write(oprot)
4783 phani.kuma 13433 
      oprot.writeListEnd()
13434 
      oprot.writeFieldEnd()
13435 
    oprot.writeFieldStop()
13436 
    oprot.writeStructEnd()
13437 
 
13438 
  def validate(self):
13439 
    return
13440 
 
13441 
 
13442 
  def __repr__(self):
13443 
    L = ['%s=%r' % (key, value)
13444 
      for key, value in self.__dict__.iteritems()]
13445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13446 
 
13447 
  def __eq__(self, other):
13448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13449 
 
13450 
  def __ne__(self, other):
13451 
    return not (self == other)
13452 
 
2536 chandransh 13453 
class toggleDOAFlag_args:
13454 
  """
13455 
  Attributes:
13456 
   - orderId
13457 
  """
1886 ankur.sing 13458 
 
2536 chandransh 13459 
  thrift_spec = (
13460 
    None, # 0
13461 
    (1, TType.I64, 'orderId', None, None, ), # 1
13462 
  )
13463 
 
13464 
  def __init__(self, orderId=None,):
13465 
    self.orderId = orderId
13466 
 
13467 
  def read(self, iprot):
13468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13470 
      return
13471 
    iprot.readStructBegin()
13472 
    while True:
13473 
      (fname, ftype, fid) = iprot.readFieldBegin()
13474 
      if ftype == TType.STOP:
13475 
        break
13476 
      if fid == 1:
13477 
        if ftype == TType.I64:
13478 
          self.orderId = iprot.readI64();
13479 
        else:
13480 
          iprot.skip(ftype)
13481 
      else:
13482 
        iprot.skip(ftype)
13483 
      iprot.readFieldEnd()
13484 
    iprot.readStructEnd()
13485 
 
13486 
  def write(self, oprot):
13487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13489 
      return
13490 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13491 
    if self.orderId is not None:
2536 chandransh 13492 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13493 
      oprot.writeI64(self.orderId)
13494 
      oprot.writeFieldEnd()
13495 
    oprot.writeFieldStop()
13496 
    oprot.writeStructEnd()
13497 
 
3431 rajveer 13498 
  def validate(self):
13499 
    return
13500 
 
13501 
 
2536 chandransh 13502 
  def __repr__(self):
13503 
    L = ['%s=%r' % (key, value)
13504 
      for key, value in self.__dict__.iteritems()]
13505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13506 
 
13507 
  def __eq__(self, other):
13508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13509 
 
13510 
  def __ne__(self, other):
13511 
    return not (self == other)
13512 
 
13513 
class toggleDOAFlag_result:
13514 
  """
13515 
  Attributes:
13516 
   - success
13517 
   - ex
13518 
  """
13519 
 
13520 
  thrift_spec = (
13521 
    (0, TType.BOOL, 'success', None, None, ), # 0
13522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13523 
  )
13524 
 
13525 
  def __init__(self, success=None, ex=None,):
13526 
    self.success = success
13527 
    self.ex = ex
13528 
 
13529 
  def read(self, iprot):
13530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13532 
      return
13533 
    iprot.readStructBegin()
13534 
    while True:
13535 
      (fname, ftype, fid) = iprot.readFieldBegin()
13536 
      if ftype == TType.STOP:
13537 
        break
13538 
      if fid == 0:
13539 
        if ftype == TType.BOOL:
13540 
          self.success = iprot.readBool();
13541 
        else:
13542 
          iprot.skip(ftype)
13543 
      elif fid == 1:
13544 
        if ftype == TType.STRUCT:
13545 
          self.ex = TransactionServiceException()
13546 
          self.ex.read(iprot)
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
13558 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13559 
    if self.success is not None:
2536 chandransh 13560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13561 
      oprot.writeBool(self.success)
13562 
      oprot.writeFieldEnd()
3431 rajveer 13563 
    if self.ex is not None:
2536 chandransh 13564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13565 
      self.ex.write(oprot)
13566 
      oprot.writeFieldEnd()
13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
3431 rajveer 13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
2536 chandransh 13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
13584 
 
4712 rajveer 13585 
class markOrderAsDelivered_args:
13586 
  """
13587 
  Attributes:
13588 
   - orderId
13589 
   - deliveryTimestamp
13590 
   - receiver
13591 
  """
13592 
 
13593 
  thrift_spec = None
13594 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13595 
    self.orderId = orderId
13596 
    self.deliveryTimestamp = deliveryTimestamp
13597 
    self.receiver = receiver
13598 
 
13599 
  def read(self, iprot):
13600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13602 
      return
13603 
    iprot.readStructBegin()
13604 
    while True:
13605 
      (fname, ftype, fid) = iprot.readFieldBegin()
13606 
      if ftype == TType.STOP:
13607 
        break
13608 
      if fid == 1:
13609 
        if ftype == TType.I64:
13610 
          self.orderId = iprot.readI64();
13611 
        else:
13612 
          iprot.skip(ftype)
13613 
      elif fid == 2:
13614 
        if ftype == TType.I64:
13615 
          self.deliveryTimestamp = iprot.readI64();
13616 
        else:
13617 
          iprot.skip(ftype)
13618 
      elif fid == -1:
13619 
        if ftype == TType.STRING:
13620 
          self.receiver = iprot.readString();
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      else:
13624 
        iprot.skip(ftype)
13625 
      iprot.readFieldEnd()
13626 
    iprot.readStructEnd()
13627 
 
13628 
  def write(self, oprot):
13629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13631 
      return
13632 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13633 
    if self.receiver is not None:
13634 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13635 
      oprot.writeString(self.receiver)
13636 
      oprot.writeFieldEnd()
13637 
    if self.orderId is not None:
13638 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13639 
      oprot.writeI64(self.orderId)
13640 
      oprot.writeFieldEnd()
13641 
    if self.deliveryTimestamp is not None:
13642 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13643 
      oprot.writeI64(self.deliveryTimestamp)
13644 
      oprot.writeFieldEnd()
13645 
    oprot.writeFieldStop()
13646 
    oprot.writeStructEnd()
13647 
 
13648 
  def validate(self):
13649 
    return
13650 
 
13651 
 
13652 
  def __repr__(self):
13653 
    L = ['%s=%r' % (key, value)
13654 
      for key, value in self.__dict__.iteritems()]
13655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13656 
 
13657 
  def __eq__(self, other):
13658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13659 
 
13660 
  def __ne__(self, other):
13661 
    return not (self == other)
13662 
 
13663 
class markOrderAsDelivered_result:
13664 
  """
13665 
  Attributes:
13666 
   - ex
13667 
  """
13668 
 
13669 
  thrift_spec = (
13670 
    None, # 0
13671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13672 
  )
13673 
 
13674 
  def __init__(self, ex=None,):
13675 
    self.ex = ex
13676 
 
13677 
  def read(self, iprot):
13678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13680 
      return
13681 
    iprot.readStructBegin()
13682 
    while True:
13683 
      (fname, ftype, fid) = iprot.readFieldBegin()
13684 
      if ftype == TType.STOP:
13685 
        break
13686 
      if fid == 1:
13687 
        if ftype == TType.STRUCT:
13688 
          self.ex = TransactionServiceException()
13689 
          self.ex.read(iprot)
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      else:
13693 
        iprot.skip(ftype)
13694 
      iprot.readFieldEnd()
13695 
    iprot.readStructEnd()
13696 
 
13697 
  def write(self, oprot):
13698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13700 
      return
13701 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13702 
    if self.ex is not None:
13703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13704 
      self.ex.write(oprot)
13705 
      oprot.writeFieldEnd()
13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
4454 rajveer 13724 
class markOrderDoaRequestReceived_args:
13725 
  """
13726 
  Attributes:
13727 
   - orderId
13728 
  """
13729 
 
13730 
  thrift_spec = (
13731 
    None, # 0
13732 
    (1, TType.I64, 'orderId', None, None, ), # 1
13733 
  )
13734 
 
13735 
  def __init__(self, orderId=None,):
13736 
    self.orderId = orderId
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 1:
13748 
        if ftype == TType.I64:
13749 
          self.orderId = iprot.readI64();
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      else:
13753 
        iprot.skip(ftype)
13754 
      iprot.readFieldEnd()
13755 
    iprot.readStructEnd()
13756 
 
13757 
  def write(self, oprot):
13758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13760 
      return
13761 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13762 
    if self.orderId is not None:
13763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13764 
      oprot.writeI64(self.orderId)
13765 
      oprot.writeFieldEnd()
13766 
    oprot.writeFieldStop()
13767 
    oprot.writeStructEnd()
13768 
 
13769 
  def validate(self):
13770 
    return
13771 
 
13772 
 
13773 
  def __repr__(self):
13774 
    L = ['%s=%r' % (key, value)
13775 
      for key, value in self.__dict__.iteritems()]
13776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13777 
 
13778 
  def __eq__(self, other):
13779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13780 
 
13781 
  def __ne__(self, other):
13782 
    return not (self == other)
13783 
 
13784 
class markOrderDoaRequestReceived_result:
13785 
  """
13786 
  Attributes:
13787 
   - success
13788 
   - ex
13789 
  """
13790 
 
13791 
  thrift_spec = (
13792 
    (0, TType.BOOL, 'success', None, None, ), # 0
13793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13794 
  )
13795 
 
13796 
  def __init__(self, success=None, ex=None,):
13797 
    self.success = success
13798 
    self.ex = ex
13799 
 
13800 
  def read(self, iprot):
13801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13803 
      return
13804 
    iprot.readStructBegin()
13805 
    while True:
13806 
      (fname, ftype, fid) = iprot.readFieldBegin()
13807 
      if ftype == TType.STOP:
13808 
        break
13809 
      if fid == 0:
13810 
        if ftype == TType.BOOL:
13811 
          self.success = iprot.readBool();
13812 
        else:
13813 
          iprot.skip(ftype)
13814 
      elif fid == 1:
13815 
        if ftype == TType.STRUCT:
13816 
          self.ex = TransactionServiceException()
13817 
          self.ex.read(iprot)
13818 
        else:
13819 
          iprot.skip(ftype)
13820 
      else:
13821 
        iprot.skip(ftype)
13822 
      iprot.readFieldEnd()
13823 
    iprot.readStructEnd()
13824 
 
13825 
  def write(self, oprot):
13826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13828 
      return
13829 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13830 
    if self.success is not None:
13831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13832 
      oprot.writeBool(self.success)
13833 
      oprot.writeFieldEnd()
13834 
    if self.ex is not None:
13835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13836 
      self.ex.write(oprot)
13837 
      oprot.writeFieldEnd()
13838 
    oprot.writeFieldStop()
13839 
    oprot.writeStructEnd()
13840 
 
13841 
  def validate(self):
13842 
    return
13843 
 
13844 
 
13845 
  def __repr__(self):
13846 
    L = ['%s=%r' % (key, value)
13847 
      for key, value in self.__dict__.iteritems()]
13848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13849 
 
13850 
  def __eq__(self, other):
13851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13852 
 
13853 
  def __ne__(self, other):
13854 
    return not (self == other)
13855 
 
13856 
class markOrderDoaRequestAuthorized_args:
13857 
  """
13858 
  Attributes:
13859 
   - orderId
13860 
   - isAuthorized
13861 
  """
13862 
 
13863 
  thrift_spec = (
13864 
    None, # 0
13865 
    (1, TType.I64, 'orderId', None, None, ), # 1
13866 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
13867 
  )
13868 
 
13869 
  def __init__(self, orderId=None, isAuthorized=None,):
13870 
    self.orderId = orderId
13871 
    self.isAuthorized = isAuthorized
13872 
 
13873 
  def read(self, iprot):
13874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13876 
      return
13877 
    iprot.readStructBegin()
13878 
    while True:
13879 
      (fname, ftype, fid) = iprot.readFieldBegin()
13880 
      if ftype == TType.STOP:
13881 
        break
13882 
      if fid == 1:
13883 
        if ftype == TType.I64:
13884 
          self.orderId = iprot.readI64();
13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      elif fid == 2:
13888 
        if ftype == TType.BOOL:
13889 
          self.isAuthorized = iprot.readBool();
13890 
        else:
13891 
          iprot.skip(ftype)
13892 
      else:
13893 
        iprot.skip(ftype)
13894 
      iprot.readFieldEnd()
13895 
    iprot.readStructEnd()
13896 
 
13897 
  def write(self, oprot):
13898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13900 
      return
13901 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
13902 
    if self.orderId is not None:
13903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13904 
      oprot.writeI64(self.orderId)
13905 
      oprot.writeFieldEnd()
13906 
    if self.isAuthorized is not None:
13907 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
13908 
      oprot.writeBool(self.isAuthorized)
13909 
      oprot.writeFieldEnd()
13910 
    oprot.writeFieldStop()
13911 
    oprot.writeStructEnd()
13912 
 
13913 
  def validate(self):
13914 
    return
13915 
 
13916 
 
13917 
  def __repr__(self):
13918 
    L = ['%s=%r' % (key, value)
13919 
      for key, value in self.__dict__.iteritems()]
13920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13921 
 
13922 
  def __eq__(self, other):
13923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13924 
 
13925 
  def __ne__(self, other):
13926 
    return not (self == other)
13927 
 
13928 
class markOrderDoaRequestAuthorized_result:
13929 
  """
13930 
  Attributes:
13931 
   - success
13932 
   - ex
13933 
  """
13934 
 
13935 
  thrift_spec = (
13936 
    (0, TType.BOOL, 'success', None, None, ), # 0
13937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13938 
  )
13939 
 
13940 
  def __init__(self, success=None, ex=None,):
13941 
    self.success = success
13942 
    self.ex = ex
13943 
 
13944 
  def read(self, iprot):
13945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13947 
      return
13948 
    iprot.readStructBegin()
13949 
    while True:
13950 
      (fname, ftype, fid) = iprot.readFieldBegin()
13951 
      if ftype == TType.STOP:
13952 
        break
13953 
      if fid == 0:
13954 
        if ftype == TType.BOOL:
13955 
          self.success = iprot.readBool();
13956 
        else:
13957 
          iprot.skip(ftype)
13958 
      elif fid == 1:
13959 
        if ftype == TType.STRUCT:
13960 
          self.ex = TransactionServiceException()
13961 
          self.ex.read(iprot)
13962 
        else:
13963 
          iprot.skip(ftype)
13964 
      else:
13965 
        iprot.skip(ftype)
13966 
      iprot.readFieldEnd()
13967 
    iprot.readStructEnd()
13968 
 
13969 
  def write(self, oprot):
13970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13972 
      return
13973 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
13974 
    if self.success is not None:
13975 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13976 
      oprot.writeBool(self.success)
13977 
      oprot.writeFieldEnd()
13978 
    if self.ex is not None:
13979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13980 
      self.ex.write(oprot)
13981 
      oprot.writeFieldEnd()
13982 
    oprot.writeFieldStop()
13983 
    oprot.writeStructEnd()
13984 
 
13985 
  def validate(self):
13986 
    return
13987 
 
13988 
 
13989 
  def __repr__(self):
13990 
    L = ['%s=%r' % (key, value)
13991 
      for key, value in self.__dict__.iteritems()]
13992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13993 
 
13994 
  def __eq__(self, other):
13995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13996 
 
13997 
  def __ne__(self, other):
13998 
    return not (self == other)
13999 
 
4488 rajveer 14000 
class markOrderReturnRequestReceived_args:
14001 
  """
14002 
  Attributes:
14003 
   - orderId
14004 
  """
14005 
 
14006 
  thrift_spec = (
14007 
    None, # 0
14008 
    (1, TType.I64, 'orderId', None, None, ), # 1
14009 
  )
14010 
 
14011 
  def __init__(self, orderId=None,):
14012 
    self.orderId = orderId
14013 
 
14014 
  def read(self, iprot):
14015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14017 
      return
14018 
    iprot.readStructBegin()
14019 
    while True:
14020 
      (fname, ftype, fid) = iprot.readFieldBegin()
14021 
      if ftype == TType.STOP:
14022 
        break
14023 
      if fid == 1:
14024 
        if ftype == TType.I64:
14025 
          self.orderId = iprot.readI64();
14026 
        else:
14027 
          iprot.skip(ftype)
14028 
      else:
14029 
        iprot.skip(ftype)
14030 
      iprot.readFieldEnd()
14031 
    iprot.readStructEnd()
14032 
 
14033 
  def write(self, oprot):
14034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14036 
      return
14037 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14038 
    if self.orderId is not None:
14039 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14040 
      oprot.writeI64(self.orderId)
14041 
      oprot.writeFieldEnd()
14042 
    oprot.writeFieldStop()
14043 
    oprot.writeStructEnd()
14044 
 
14045 
  def validate(self):
14046 
    return
14047 
 
14048 
 
14049 
  def __repr__(self):
14050 
    L = ['%s=%r' % (key, value)
14051 
      for key, value in self.__dict__.iteritems()]
14052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14053 
 
14054 
  def __eq__(self, other):
14055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14056 
 
14057 
  def __ne__(self, other):
14058 
    return not (self == other)
14059 
 
14060 
class markOrderReturnRequestReceived_result:
14061 
  """
14062 
  Attributes:
14063 
   - success
14064 
   - ex
14065 
  """
14066 
 
14067 
  thrift_spec = (
14068 
    (0, TType.BOOL, 'success', None, None, ), # 0
14069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14070 
  )
14071 
 
14072 
  def __init__(self, success=None, ex=None,):
14073 
    self.success = success
14074 
    self.ex = ex
14075 
 
14076 
  def read(self, iprot):
14077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14079 
      return
14080 
    iprot.readStructBegin()
14081 
    while True:
14082 
      (fname, ftype, fid) = iprot.readFieldBegin()
14083 
      if ftype == TType.STOP:
14084 
        break
14085 
      if fid == 0:
14086 
        if ftype == TType.BOOL:
14087 
          self.success = iprot.readBool();
14088 
        else:
14089 
          iprot.skip(ftype)
14090 
      elif fid == 1:
14091 
        if ftype == TType.STRUCT:
14092 
          self.ex = TransactionServiceException()
14093 
          self.ex.read(iprot)
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
14105 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14106 
    if self.success is not None:
14107 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14108 
      oprot.writeBool(self.success)
14109 
      oprot.writeFieldEnd()
14110 
    if self.ex is not None:
14111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14112 
      self.ex.write(oprot)
14113 
      oprot.writeFieldEnd()
14114 
    oprot.writeFieldStop()
14115 
    oprot.writeStructEnd()
14116 
 
14117 
  def validate(self):
14118 
    return
14119 
 
14120 
 
14121 
  def __repr__(self):
14122 
    L = ['%s=%r' % (key, value)
14123 
      for key, value in self.__dict__.iteritems()]
14124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14125 
 
14126 
  def __eq__(self, other):
14127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14128 
 
14129 
  def __ne__(self, other):
14130 
    return not (self == other)
14131 
 
14132 
class markOrderReturnRequestAuthorized_args:
14133 
  """
14134 
  Attributes:
14135 
   - orderId
14136 
   - isAuthorized
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    None, # 0
14141 
    (1, TType.I64, 'orderId', None, None, ), # 1
14142 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14143 
  )
14144 
 
14145 
  def __init__(self, orderId=None, isAuthorized=None,):
14146 
    self.orderId = orderId
14147 
    self.isAuthorized = isAuthorized
14148 
 
14149 
  def read(self, iprot):
14150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14152 
      return
14153 
    iprot.readStructBegin()
14154 
    while True:
14155 
      (fname, ftype, fid) = iprot.readFieldBegin()
14156 
      if ftype == TType.STOP:
14157 
        break
14158 
      if fid == 1:
14159 
        if ftype == TType.I64:
14160 
          self.orderId = iprot.readI64();
14161 
        else:
14162 
          iprot.skip(ftype)
14163 
      elif fid == 2:
14164 
        if ftype == TType.BOOL:
14165 
          self.isAuthorized = iprot.readBool();
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14178 
    if self.orderId is not None:
14179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14180 
      oprot.writeI64(self.orderId)
14181 
      oprot.writeFieldEnd()
14182 
    if self.isAuthorized is not None:
14183 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14184 
      oprot.writeBool(self.isAuthorized)
14185 
      oprot.writeFieldEnd()
14186 
    oprot.writeFieldStop()
14187 
    oprot.writeStructEnd()
14188 
 
14189 
  def validate(self):
14190 
    return
14191 
 
14192 
 
14193 
  def __repr__(self):
14194 
    L = ['%s=%r' % (key, value)
14195 
      for key, value in self.__dict__.iteritems()]
14196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14197 
 
14198 
  def __eq__(self, other):
14199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14200 
 
14201 
  def __ne__(self, other):
14202 
    return not (self == other)
14203 
 
14204 
class markOrderReturnRequestAuthorized_result:
14205 
  """
14206 
  Attributes:
14207 
   - success
14208 
   - ex
14209 
  """
14210 
 
14211 
  thrift_spec = (
14212 
    (0, TType.BOOL, 'success', None, None, ), # 0
14213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14214 
  )
14215 
 
14216 
  def __init__(self, success=None, ex=None,):
14217 
    self.success = success
14218 
    self.ex = ex
14219 
 
14220 
  def read(self, iprot):
14221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14223 
      return
14224 
    iprot.readStructBegin()
14225 
    while True:
14226 
      (fname, ftype, fid) = iprot.readFieldBegin()
14227 
      if ftype == TType.STOP:
14228 
        break
14229 
      if fid == 0:
14230 
        if ftype == TType.BOOL:
14231 
          self.success = iprot.readBool();
14232 
        else:
14233 
          iprot.skip(ftype)
14234 
      elif fid == 1:
14235 
        if ftype == TType.STRUCT:
14236 
          self.ex = TransactionServiceException()
14237 
          self.ex.read(iprot)
14238 
        else:
14239 
          iprot.skip(ftype)
14240 
      else:
14241 
        iprot.skip(ftype)
14242 
      iprot.readFieldEnd()
14243 
    iprot.readStructEnd()
14244 
 
14245 
  def write(self, oprot):
14246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14248 
      return
14249 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14250 
    if self.success is not None:
14251 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14252 
      oprot.writeBool(self.success)
14253 
      oprot.writeFieldEnd()
14254 
    if self.ex is not None:
14255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14256 
      self.ex.write(oprot)
14257 
      oprot.writeFieldEnd()
14258 
    oprot.writeFieldStop()
14259 
    oprot.writeStructEnd()
14260 
 
14261 
  def validate(self):
14262 
    return
14263 
 
14264 
 
14265 
  def __repr__(self):
14266 
    L = ['%s=%r' % (key, value)
14267 
      for key, value in self.__dict__.iteritems()]
14268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14269 
 
14270 
  def __eq__(self, other):
14271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14272 
 
14273 
  def __ne__(self, other):
14274 
    return not (self == other)
14275 
 
2536 chandransh 14276 
class requestPickupNumber_args:
14277 
  """
14278 
  Attributes:
14279 
   - orderId
4579 rajveer 14280 
   - providerId
2536 chandransh 14281 
  """
14282 
 
14283 
  thrift_spec = (
14284 
    None, # 0
14285 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14286 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14287 
  )
14288 
 
4579 rajveer 14289 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14290 
    self.orderId = orderId
4579 rajveer 14291 
    self.providerId = providerId
2536 chandransh 14292 
 
14293 
  def read(self, iprot):
14294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14296 
      return
14297 
    iprot.readStructBegin()
14298 
    while True:
14299 
      (fname, ftype, fid) = iprot.readFieldBegin()
14300 
      if ftype == TType.STOP:
14301 
        break
14302 
      if fid == 1:
14303 
        if ftype == TType.I64:
14304 
          self.orderId = iprot.readI64();
14305 
        else:
14306 
          iprot.skip(ftype)
4579 rajveer 14307 
      elif fid == 2:
14308 
        if ftype == TType.I64:
14309 
          self.providerId = iprot.readI64();
14310 
        else:
14311 
          iprot.skip(ftype)
2536 chandransh 14312 
      else:
14313 
        iprot.skip(ftype)
14314 
      iprot.readFieldEnd()
14315 
    iprot.readStructEnd()
14316 
 
14317 
  def write(self, oprot):
14318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14320 
      return
14321 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14322 
    if self.orderId is not None:
2536 chandransh 14323 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14324 
      oprot.writeI64(self.orderId)
14325 
      oprot.writeFieldEnd()
4579 rajveer 14326 
    if self.providerId is not None:
14327 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14328 
      oprot.writeI64(self.providerId)
14329 
      oprot.writeFieldEnd()
2536 chandransh 14330 
    oprot.writeFieldStop()
14331 
    oprot.writeStructEnd()
14332 
 
3431 rajveer 14333 
  def validate(self):
14334 
    return
14335 
 
14336 
 
2536 chandransh 14337 
  def __repr__(self):
14338 
    L = ['%s=%r' % (key, value)
14339 
      for key, value in self.__dict__.iteritems()]
14340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14341 
 
14342 
  def __eq__(self, other):
14343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14344 
 
14345 
  def __ne__(self, other):
14346 
    return not (self == other)
14347 
 
14348 
class requestPickupNumber_result:
14349 
  """
14350 
  Attributes:
14351 
   - success
14352 
   - ex
14353 
  """
14354 
 
14355 
  thrift_spec = (
14356 
    (0, TType.BOOL, 'success', None, None, ), # 0
14357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14358 
  )
14359 
 
14360 
  def __init__(self, success=None, ex=None,):
14361 
    self.success = success
14362 
    self.ex = ex
14363 
 
14364 
  def read(self, iprot):
14365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14367 
      return
14368 
    iprot.readStructBegin()
14369 
    while True:
14370 
      (fname, ftype, fid) = iprot.readFieldBegin()
14371 
      if ftype == TType.STOP:
14372 
        break
14373 
      if fid == 0:
14374 
        if ftype == TType.BOOL:
14375 
          self.success = iprot.readBool();
14376 
        else:
14377 
          iprot.skip(ftype)
14378 
      elif fid == 1:
14379 
        if ftype == TType.STRUCT:
14380 
          self.ex = TransactionServiceException()
14381 
          self.ex.read(iprot)
14382 
        else:
14383 
          iprot.skip(ftype)
14384 
      else:
14385 
        iprot.skip(ftype)
14386 
      iprot.readFieldEnd()
14387 
    iprot.readStructEnd()
14388 
 
14389 
  def write(self, oprot):
14390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14392 
      return
14393 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14394 
    if self.success is not None:
2536 chandransh 14395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14396 
      oprot.writeBool(self.success)
14397 
      oprot.writeFieldEnd()
3431 rajveer 14398 
    if self.ex is not None:
2536 chandransh 14399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14400 
      self.ex.write(oprot)
14401 
      oprot.writeFieldEnd()
14402 
    oprot.writeFieldStop()
14403 
    oprot.writeStructEnd()
14404 
 
3431 rajveer 14405 
  def validate(self):
14406 
    return
14407 
 
14408 
 
2536 chandransh 14409 
  def __repr__(self):
14410 
    L = ['%s=%r' % (key, value)
14411 
      for key, value in self.__dict__.iteritems()]
14412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14413 
 
14414 
  def __eq__(self, other):
14415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14416 
 
14417 
  def __ne__(self, other):
14418 
    return not (self == other)
14419 
 
14420 
class authorizePickup_args:
14421 
  """
14422 
  Attributes:
14423 
   - orderId
14424 
   - pickupNumber
4602 rajveer 14425 
   - providerId
2536 chandransh 14426 
  """
14427 
 
14428 
  thrift_spec = (
14429 
    None, # 0
14430 
    (1, TType.I64, 'orderId', None, None, ), # 1
14431 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14432 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14433 
  )
14434 
 
4602 rajveer 14435 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14436 
    self.orderId = orderId
14437 
    self.pickupNumber = pickupNumber
4602 rajveer 14438 
    self.providerId = providerId
2536 chandransh 14439 
 
14440 
  def read(self, iprot):
14441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14443 
      return
14444 
    iprot.readStructBegin()
14445 
    while True:
14446 
      (fname, ftype, fid) = iprot.readFieldBegin()
14447 
      if ftype == TType.STOP:
14448 
        break
14449 
      if fid == 1:
14450 
        if ftype == TType.I64:
14451 
          self.orderId = iprot.readI64();
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      elif fid == 2:
14455 
        if ftype == TType.STRING:
14456 
          self.pickupNumber = iprot.readString();
14457 
        else:
14458 
          iprot.skip(ftype)
4602 rajveer 14459 
      elif fid == 3:
14460 
        if ftype == TType.I64:
14461 
          self.providerId = iprot.readI64();
14462 
        else:
14463 
          iprot.skip(ftype)
2536 chandransh 14464 
      else:
14465 
        iprot.skip(ftype)
14466 
      iprot.readFieldEnd()
14467 
    iprot.readStructEnd()
14468 
 
14469 
  def write(self, oprot):
14470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14472 
      return
14473 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14474 
    if self.orderId is not None:
2536 chandransh 14475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14476 
      oprot.writeI64(self.orderId)
14477 
      oprot.writeFieldEnd()
3431 rajveer 14478 
    if self.pickupNumber is not None:
2536 chandransh 14479 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14480 
      oprot.writeString(self.pickupNumber)
14481 
      oprot.writeFieldEnd()
4602 rajveer 14482 
    if self.providerId is not None:
14483 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14484 
      oprot.writeI64(self.providerId)
14485 
      oprot.writeFieldEnd()
2536 chandransh 14486 
    oprot.writeFieldStop()
14487 
    oprot.writeStructEnd()
14488 
 
3431 rajveer 14489 
  def validate(self):
14490 
    return
14491 
 
14492 
 
2536 chandransh 14493 
  def __repr__(self):
14494 
    L = ['%s=%r' % (key, value)
14495 
      for key, value in self.__dict__.iteritems()]
14496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14497 
 
14498 
  def __eq__(self, other):
14499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14500 
 
14501 
  def __ne__(self, other):
14502 
    return not (self == other)
14503 
 
14504 
class authorizePickup_result:
14505 
  """
14506 
  Attributes:
14507 
   - success
14508 
   - ex
14509 
  """
14510 
 
14511 
  thrift_spec = (
14512 
    (0, TType.BOOL, 'success', None, None, ), # 0
14513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14514 
  )
14515 
 
14516 
  def __init__(self, success=None, ex=None,):
14517 
    self.success = success
14518 
    self.ex = ex
14519 
 
14520 
  def read(self, iprot):
14521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14523 
      return
14524 
    iprot.readStructBegin()
14525 
    while True:
14526 
      (fname, ftype, fid) = iprot.readFieldBegin()
14527 
      if ftype == TType.STOP:
14528 
        break
14529 
      if fid == 0:
14530 
        if ftype == TType.BOOL:
14531 
          self.success = iprot.readBool();
14532 
        else:
14533 
          iprot.skip(ftype)
14534 
      elif fid == 1:
14535 
        if ftype == TType.STRUCT:
14536 
          self.ex = TransactionServiceException()
14537 
          self.ex.read(iprot)
14538 
        else:
14539 
          iprot.skip(ftype)
14540 
      else:
14541 
        iprot.skip(ftype)
14542 
      iprot.readFieldEnd()
14543 
    iprot.readStructEnd()
14544 
 
14545 
  def write(self, oprot):
14546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14548 
      return
14549 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14550 
    if self.success is not None:
2536 chandransh 14551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14552 
      oprot.writeBool(self.success)
14553 
      oprot.writeFieldEnd()
3431 rajveer 14554 
    if self.ex is not None:
2536 chandransh 14555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14556 
      self.ex.write(oprot)
14557 
      oprot.writeFieldEnd()
14558 
    oprot.writeFieldStop()
14559 
    oprot.writeStructEnd()
14560 
 
3431 rajveer 14561 
  def validate(self):
14562 
    return
14563 
 
14564 
 
2536 chandransh 14565 
  def __repr__(self):
14566 
    L = ['%s=%r' % (key, value)
14567 
      for key, value in self.__dict__.iteritems()]
14568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14569 
 
14570 
  def __eq__(self, other):
14571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14572 
 
14573 
  def __ne__(self, other):
14574 
    return not (self == other)
14575 
 
2764 chandransh 14576 
class markDoasAsPickedUp_args:
14577 
  """
14578 
  Attributes:
14579 
   - providerId
14580 
   - pickupDetails
14581 
  """
14582 
 
14583 
  thrift_spec = (
14584 
    None, # 0
14585 
    (1, TType.I64, 'providerId', None, None, ), # 1
14586 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14587 
  )
14588 
 
14589 
  def __init__(self, providerId=None, pickupDetails=None,):
14590 
    self.providerId = providerId
14591 
    self.pickupDetails = pickupDetails
14592 
 
14593 
  def read(self, iprot):
14594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14596 
      return
14597 
    iprot.readStructBegin()
14598 
    while True:
14599 
      (fname, ftype, fid) = iprot.readFieldBegin()
14600 
      if ftype == TType.STOP:
14601 
        break
14602 
      if fid == 1:
14603 
        if ftype == TType.I64:
14604 
          self.providerId = iprot.readI64();
14605 
        else:
14606 
          iprot.skip(ftype)
14607 
      elif fid == 2:
14608 
        if ftype == TType.MAP:
14609 
          self.pickupDetails = {}
4999 phani.kuma 14610 
          (_ktype316, _vtype317, _size315 ) = iprot.readMapBegin()
14611 
          for _i319 in xrange(_size315):
14612 
            _key320 = iprot.readString();
14613 
            _val321 = iprot.readString();
14614 
            self.pickupDetails[_key320] = _val321
2764 chandransh 14615 
          iprot.readMapEnd()
14616 
        else:
14617 
          iprot.skip(ftype)
14618 
      else:
14619 
        iprot.skip(ftype)
14620 
      iprot.readFieldEnd()
14621 
    iprot.readStructEnd()
14622 
 
14623 
  def write(self, oprot):
14624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14626 
      return
14627 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14628 
    if self.providerId is not None:
2764 chandransh 14629 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14630 
      oprot.writeI64(self.providerId)
14631 
      oprot.writeFieldEnd()
3431 rajveer 14632 
    if self.pickupDetails is not None:
2764 chandransh 14633 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14634 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4999 phani.kuma 14635 
      for kiter322,viter323 in self.pickupDetails.items():
14636 
        oprot.writeString(kiter322)
14637 
        oprot.writeString(viter323)
2764 chandransh 14638 
      oprot.writeMapEnd()
14639 
      oprot.writeFieldEnd()
14640 
    oprot.writeFieldStop()
14641 
    oprot.writeStructEnd()
14642 
 
3431 rajveer 14643 
  def validate(self):
14644 
    return
14645 
 
14646 
 
2764 chandransh 14647 
  def __repr__(self):
14648 
    L = ['%s=%r' % (key, value)
14649 
      for key, value in self.__dict__.iteritems()]
14650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14651 
 
14652 
  def __eq__(self, other):
14653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14654 
 
14655 
  def __ne__(self, other):
14656 
    return not (self == other)
14657 
 
14658 
class markDoasAsPickedUp_result:
4910 phani.kuma 14659 
 
14660 
  thrift_spec = (
14661 
  )
14662 
 
14663 
  def read(self, iprot):
14664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14666 
      return
14667 
    iprot.readStructBegin()
14668 
    while True:
14669 
      (fname, ftype, fid) = iprot.readFieldBegin()
14670 
      if ftype == TType.STOP:
14671 
        break
14672 
      else:
14673 
        iprot.skip(ftype)
14674 
      iprot.readFieldEnd()
14675 
    iprot.readStructEnd()
14676 
 
14677 
  def write(self, oprot):
14678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14680 
      return
14681 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14682 
    oprot.writeFieldStop()
14683 
    oprot.writeStructEnd()
14684 
 
14685 
  def validate(self):
14686 
    return
14687 
 
14688 
 
14689 
  def __repr__(self):
14690 
    L = ['%s=%r' % (key, value)
14691 
      for key, value in self.__dict__.iteritems()]
14692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14693 
 
14694 
  def __eq__(self, other):
14695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14696 
 
14697 
  def __ne__(self, other):
14698 
    return not (self == other)
14699 
 
14700 
class getDoasNotPickedUp_args:
2764 chandransh 14701 
  """
14702 
  Attributes:
4910 phani.kuma 14703 
   - providerId
14704 
  """
14705 
 
14706 
  thrift_spec = (
14707 
    None, # 0
14708 
    (1, TType.I64, 'providerId', None, None, ), # 1
14709 
  )
14710 
 
14711 
  def __init__(self, providerId=None,):
14712 
    self.providerId = providerId
14713 
 
14714 
  def read(self, iprot):
14715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14717 
      return
14718 
    iprot.readStructBegin()
14719 
    while True:
14720 
      (fname, ftype, fid) = iprot.readFieldBegin()
14721 
      if ftype == TType.STOP:
14722 
        break
14723 
      if fid == 1:
14724 
        if ftype == TType.I64:
14725 
          self.providerId = iprot.readI64();
14726 
        else:
14727 
          iprot.skip(ftype)
14728 
      else:
14729 
        iprot.skip(ftype)
14730 
      iprot.readFieldEnd()
14731 
    iprot.readStructEnd()
14732 
 
14733 
  def write(self, oprot):
14734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14736 
      return
14737 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14738 
    if self.providerId is not None:
14739 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14740 
      oprot.writeI64(self.providerId)
14741 
      oprot.writeFieldEnd()
14742 
    oprot.writeFieldStop()
14743 
    oprot.writeStructEnd()
14744 
 
14745 
  def validate(self):
14746 
    return
14747 
 
14748 
 
14749 
  def __repr__(self):
14750 
    L = ['%s=%r' % (key, value)
14751 
      for key, value in self.__dict__.iteritems()]
14752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14753 
 
14754 
  def __eq__(self, other):
14755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14756 
 
14757 
  def __ne__(self, other):
14758 
    return not (self == other)
14759 
 
14760 
class getDoasNotPickedUp_result:
14761 
  """
14762 
  Attributes:
2764 chandransh 14763 
   - success
14764 
  """
14765 
 
14766 
  thrift_spec = (
14767 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14768 
  )
14769 
 
14770 
  def __init__(self, success=None,):
14771 
    self.success = success
14772 
 
14773 
  def read(self, iprot):
14774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14776 
      return
14777 
    iprot.readStructBegin()
14778 
    while True:
14779 
      (fname, ftype, fid) = iprot.readFieldBegin()
14780 
      if ftype == TType.STOP:
14781 
        break
14782 
      if fid == 0:
14783 
        if ftype == TType.LIST:
14784 
          self.success = []
4999 phani.kuma 14785 
          (_etype327, _size324) = iprot.readListBegin()
14786 
          for _i328 in xrange(_size324):
14787 
            _elem329 = Order()
14788 
            _elem329.read(iprot)
14789 
            self.success.append(_elem329)
2764 chandransh 14790 
          iprot.readListEnd()
14791 
        else:
14792 
          iprot.skip(ftype)
14793 
      else:
14794 
        iprot.skip(ftype)
14795 
      iprot.readFieldEnd()
14796 
    iprot.readStructEnd()
14797 
 
14798 
  def write(self, oprot):
14799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14801 
      return
4910 phani.kuma 14802 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14803 
    if self.success is not None:
2764 chandransh 14804 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14805 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 14806 
      for iter330 in self.success:
14807 
        iter330.write(oprot)
2764 chandransh 14808 
      oprot.writeListEnd()
14809 
      oprot.writeFieldEnd()
14810 
    oprot.writeFieldStop()
14811 
    oprot.writeStructEnd()
14812 
 
3431 rajveer 14813 
  def validate(self):
14814 
    return
14815 
 
14816 
 
2764 chandransh 14817 
  def __repr__(self):
14818 
    L = ['%s=%r' % (key, value)
14819 
      for key, value in self.__dict__.iteritems()]
14820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14821 
 
14822 
  def __eq__(self, other):
14823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14824 
 
14825 
  def __ne__(self, other):
14826 
    return not (self == other)
14827 
 
4741 phani.kuma 14828 
class markReturnOrdersAsPickedUp_args:
14829 
  """
14830 
  Attributes:
14831 
   - providerId
14832 
   - pickupDetails
14833 
  """
14834 
 
14835 
  thrift_spec = (
14836 
    None, # 0
14837 
    (1, TType.I64, 'providerId', None, None, ), # 1
14838 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14839 
  )
14840 
 
14841 
  def __init__(self, providerId=None, pickupDetails=None,):
14842 
    self.providerId = providerId
14843 
    self.pickupDetails = pickupDetails
14844 
 
14845 
  def read(self, iprot):
14846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14848 
      return
14849 
    iprot.readStructBegin()
14850 
    while True:
14851 
      (fname, ftype, fid) = iprot.readFieldBegin()
14852 
      if ftype == TType.STOP:
14853 
        break
14854 
      if fid == 1:
14855 
        if ftype == TType.I64:
14856 
          self.providerId = iprot.readI64();
14857 
        else:
14858 
          iprot.skip(ftype)
14859 
      elif fid == 2:
14860 
        if ftype == TType.MAP:
14861 
          self.pickupDetails = {}
4999 phani.kuma 14862 
          (_ktype332, _vtype333, _size331 ) = iprot.readMapBegin()
14863 
          for _i335 in xrange(_size331):
14864 
            _key336 = iprot.readString();
14865 
            _val337 = iprot.readString();
14866 
            self.pickupDetails[_key336] = _val337
4741 phani.kuma 14867 
          iprot.readMapEnd()
14868 
        else:
14869 
          iprot.skip(ftype)
14870 
      else:
14871 
        iprot.skip(ftype)
14872 
      iprot.readFieldEnd()
14873 
    iprot.readStructEnd()
14874 
 
14875 
  def write(self, oprot):
14876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14878 
      return
14879 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
14880 
    if self.providerId is not None:
14881 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14882 
      oprot.writeI64(self.providerId)
14883 
      oprot.writeFieldEnd()
14884 
    if self.pickupDetails is not None:
14885 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14886 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4999 phani.kuma 14887 
      for kiter338,viter339 in self.pickupDetails.items():
14888 
        oprot.writeString(kiter338)
14889 
        oprot.writeString(viter339)
4741 phani.kuma 14890 
      oprot.writeMapEnd()
14891 
      oprot.writeFieldEnd()
14892 
    oprot.writeFieldStop()
14893 
    oprot.writeStructEnd()
14894 
 
14895 
  def validate(self):
14896 
    return
14897 
 
14898 
 
14899 
  def __repr__(self):
14900 
    L = ['%s=%r' % (key, value)
14901 
      for key, value in self.__dict__.iteritems()]
14902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14903 
 
14904 
  def __eq__(self, other):
14905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14906 
 
14907 
  def __ne__(self, other):
14908 
    return not (self == other)
14909 
 
14910 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 14911 
 
14912 
  thrift_spec = (
14913 
  )
14914 
 
14915 
  def read(self, iprot):
14916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14918 
      return
14919 
    iprot.readStructBegin()
14920 
    while True:
14921 
      (fname, ftype, fid) = iprot.readFieldBegin()
14922 
      if ftype == TType.STOP:
14923 
        break
14924 
      else:
14925 
        iprot.skip(ftype)
14926 
      iprot.readFieldEnd()
14927 
    iprot.readStructEnd()
14928 
 
14929 
  def write(self, oprot):
14930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14932 
      return
14933 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
14934 
    oprot.writeFieldStop()
14935 
    oprot.writeStructEnd()
14936 
 
14937 
  def validate(self):
14938 
    return
14939 
 
14940 
 
14941 
  def __repr__(self):
14942 
    L = ['%s=%r' % (key, value)
14943 
      for key, value in self.__dict__.iteritems()]
14944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14945 
 
14946 
  def __eq__(self, other):
14947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14948 
 
14949 
  def __ne__(self, other):
14950 
    return not (self == other)
14951 
 
14952 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 14953 
  """
14954 
  Attributes:
4910 phani.kuma 14955 
   - providerId
14956 
  """
14957 
 
14958 
  thrift_spec = (
14959 
    None, # 0
14960 
    (1, TType.I64, 'providerId', None, None, ), # 1
14961 
  )
14962 
 
14963 
  def __init__(self, providerId=None,):
14964 
    self.providerId = providerId
14965 
 
14966 
  def read(self, iprot):
14967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14969 
      return
14970 
    iprot.readStructBegin()
14971 
    while True:
14972 
      (fname, ftype, fid) = iprot.readFieldBegin()
14973 
      if ftype == TType.STOP:
14974 
        break
14975 
      if fid == 1:
14976 
        if ftype == TType.I64:
14977 
          self.providerId = iprot.readI64();
14978 
        else:
14979 
          iprot.skip(ftype)
14980 
      else:
14981 
        iprot.skip(ftype)
14982 
      iprot.readFieldEnd()
14983 
    iprot.readStructEnd()
14984 
 
14985 
  def write(self, oprot):
14986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14988 
      return
14989 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
14990 
    if self.providerId is not None:
14991 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14992 
      oprot.writeI64(self.providerId)
14993 
      oprot.writeFieldEnd()
14994 
    oprot.writeFieldStop()
14995 
    oprot.writeStructEnd()
14996 
 
14997 
  def validate(self):
14998 
    return
14999 
 
15000 
 
15001 
  def __repr__(self):
15002 
    L = ['%s=%r' % (key, value)
15003 
      for key, value in self.__dict__.iteritems()]
15004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15005 
 
15006 
  def __eq__(self, other):
15007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15008 
 
15009 
  def __ne__(self, other):
15010 
    return not (self == other)
15011 
 
15012 
class getReturnOrdersNotPickedUp_result:
15013 
  """
15014 
  Attributes:
4741 phani.kuma 15015 
   - success
15016 
  """
15017 
 
15018 
  thrift_spec = (
15019 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15020 
  )
15021 
 
15022 
  def __init__(self, success=None,):
15023 
    self.success = success
15024 
 
15025 
  def read(self, iprot):
15026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15028 
      return
15029 
    iprot.readStructBegin()
15030 
    while True:
15031 
      (fname, ftype, fid) = iprot.readFieldBegin()
15032 
      if ftype == TType.STOP:
15033 
        break
15034 
      if fid == 0:
15035 
        if ftype == TType.LIST:
15036 
          self.success = []
4999 phani.kuma 15037 
          (_etype343, _size340) = iprot.readListBegin()
15038 
          for _i344 in xrange(_size340):
15039 
            _elem345 = Order()
15040 
            _elem345.read(iprot)
15041 
            self.success.append(_elem345)
4741 phani.kuma 15042 
          iprot.readListEnd()
15043 
        else:
15044 
          iprot.skip(ftype)
15045 
      else:
15046 
        iprot.skip(ftype)
15047 
      iprot.readFieldEnd()
15048 
    iprot.readStructEnd()
15049 
 
15050 
  def write(self, oprot):
15051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15053 
      return
4910 phani.kuma 15054 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15055 
    if self.success is not None:
15056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15057 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 15058 
      for iter346 in self.success:
15059 
        iter346.write(oprot)
4741 phani.kuma 15060 
      oprot.writeListEnd()
15061 
      oprot.writeFieldEnd()
15062 
    oprot.writeFieldStop()
15063 
    oprot.writeStructEnd()
15064 
 
15065 
  def validate(self):
15066 
    return
15067 
 
15068 
 
15069 
  def __repr__(self):
15070 
    L = ['%s=%r' % (key, value)
15071 
      for key, value in self.__dict__.iteritems()]
15072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15073 
 
15074 
  def __eq__(self, other):
15075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15076 
 
15077 
  def __ne__(self, other):
15078 
    return not (self == other)
15079 
 
2616 chandransh 15080 
class receiveReturn_args:
2591 chandransh 15081 
  """
15082 
  Attributes:
15083 
   - orderId
4479 rajveer 15084 
   - receiveCondition
2591 chandransh 15085 
  """
2536 chandransh 15086 
 
2591 chandransh 15087 
  thrift_spec = (
15088 
    None, # 0
15089 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15090 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15091 
  )
15092 
 
4479 rajveer 15093 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15094 
    self.orderId = orderId
4479 rajveer 15095 
    self.receiveCondition = receiveCondition
2591 chandransh 15096 
 
15097 
  def read(self, iprot):
15098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15100 
      return
15101 
    iprot.readStructBegin()
15102 
    while True:
15103 
      (fname, ftype, fid) = iprot.readFieldBegin()
15104 
      if ftype == TType.STOP:
15105 
        break
15106 
      if fid == 1:
15107 
        if ftype == TType.I64:
15108 
          self.orderId = iprot.readI64();
15109 
        else:
15110 
          iprot.skip(ftype)
4479 rajveer 15111 
      elif fid == 2:
15112 
        if ftype == TType.I64:
15113 
          self.receiveCondition = iprot.readI64();
15114 
        else:
15115 
          iprot.skip(ftype)
2591 chandransh 15116 
      else:
15117 
        iprot.skip(ftype)
15118 
      iprot.readFieldEnd()
15119 
    iprot.readStructEnd()
15120 
 
15121 
  def write(self, oprot):
15122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15124 
      return
2616 chandransh 15125 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15126 
    if self.orderId is not None:
2591 chandransh 15127 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15128 
      oprot.writeI64(self.orderId)
15129 
      oprot.writeFieldEnd()
4479 rajveer 15130 
    if self.receiveCondition is not None:
15131 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15132 
      oprot.writeI64(self.receiveCondition)
15133 
      oprot.writeFieldEnd()
2591 chandransh 15134 
    oprot.writeFieldStop()
15135 
    oprot.writeStructEnd()
15136 
 
3431 rajveer 15137 
  def validate(self):
15138 
    return
15139 
 
15140 
 
2591 chandransh 15141 
  def __repr__(self):
15142 
    L = ['%s=%r' % (key, value)
15143 
      for key, value in self.__dict__.iteritems()]
15144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15145 
 
15146 
  def __eq__(self, other):
15147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15148 
 
15149 
  def __ne__(self, other):
15150 
    return not (self == other)
15151 
 
2616 chandransh 15152 
class receiveReturn_result:
2591 chandransh 15153 
  """
15154 
  Attributes:
15155 
   - success
15156 
   - ex
15157 
  """
15158 
 
15159 
  thrift_spec = (
15160 
    (0, TType.BOOL, 'success', None, None, ), # 0
15161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15162 
  )
15163 
 
15164 
  def __init__(self, success=None, ex=None,):
15165 
    self.success = success
15166 
    self.ex = ex
15167 
 
15168 
  def read(self, iprot):
15169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15171 
      return
15172 
    iprot.readStructBegin()
15173 
    while True:
15174 
      (fname, ftype, fid) = iprot.readFieldBegin()
15175 
      if ftype == TType.STOP:
15176 
        break
15177 
      if fid == 0:
15178 
        if ftype == TType.BOOL:
15179 
          self.success = iprot.readBool();
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      elif fid == 1:
15183 
        if ftype == TType.STRUCT:
15184 
          self.ex = TransactionServiceException()
15185 
          self.ex.read(iprot)
15186 
        else:
15187 
          iprot.skip(ftype)
15188 
      else:
15189 
        iprot.skip(ftype)
15190 
      iprot.readFieldEnd()
15191 
    iprot.readStructEnd()
15192 
 
15193 
  def write(self, oprot):
15194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15196 
      return
2616 chandransh 15197 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15198 
    if self.success is not None:
2591 chandransh 15199 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15200 
      oprot.writeBool(self.success)
15201 
      oprot.writeFieldEnd()
3431 rajveer 15202 
    if self.ex is not None:
2591 chandransh 15203 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15204 
      self.ex.write(oprot)
15205 
      oprot.writeFieldEnd()
15206 
    oprot.writeFieldStop()
15207 
    oprot.writeStructEnd()
15208 
 
3431 rajveer 15209 
  def validate(self):
15210 
    return
15211 
 
15212 
 
2591 chandransh 15213 
  def __repr__(self):
15214 
    L = ['%s=%r' % (key, value)
15215 
      for key, value in self.__dict__.iteritems()]
15216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15217 
 
15218 
  def __eq__(self, other):
15219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15220 
 
15221 
  def __ne__(self, other):
15222 
    return not (self == other)
15223 
 
15224 
class validateDoa_args:
15225 
  """
15226 
  Attributes:
15227 
   - orderId
15228 
   - isValid
15229 
  """
15230 
 
15231 
  thrift_spec = (
15232 
    None, # 0
15233 
    (1, TType.I64, 'orderId', None, None, ), # 1
15234 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15235 
  )
15236 
 
15237 
  def __init__(self, orderId=None, isValid=None,):
15238 
    self.orderId = orderId
15239 
    self.isValid = isValid
15240 
 
15241 
  def read(self, iprot):
15242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15244 
      return
15245 
    iprot.readStructBegin()
15246 
    while True:
15247 
      (fname, ftype, fid) = iprot.readFieldBegin()
15248 
      if ftype == TType.STOP:
15249 
        break
15250 
      if fid == 1:
15251 
        if ftype == TType.I64:
15252 
          self.orderId = iprot.readI64();
15253 
        else:
15254 
          iprot.skip(ftype)
15255 
      elif fid == 2:
15256 
        if ftype == TType.BOOL:
15257 
          self.isValid = iprot.readBool();
15258 
        else:
15259 
          iprot.skip(ftype)
15260 
      else:
15261 
        iprot.skip(ftype)
15262 
      iprot.readFieldEnd()
15263 
    iprot.readStructEnd()
15264 
 
15265 
  def write(self, oprot):
15266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15268 
      return
15269 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15270 
    if self.orderId is not None:
2591 chandransh 15271 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15272 
      oprot.writeI64(self.orderId)
15273 
      oprot.writeFieldEnd()
3431 rajveer 15274 
    if self.isValid is not None:
2591 chandransh 15275 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15276 
      oprot.writeBool(self.isValid)
15277 
      oprot.writeFieldEnd()
15278 
    oprot.writeFieldStop()
15279 
    oprot.writeStructEnd()
15280 
 
3431 rajveer 15281 
  def validate(self):
15282 
    return
15283 
 
15284 
 
2591 chandransh 15285 
  def __repr__(self):
15286 
    L = ['%s=%r' % (key, value)
15287 
      for key, value in self.__dict__.iteritems()]
15288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15289 
 
15290 
  def __eq__(self, other):
15291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15292 
 
15293 
  def __ne__(self, other):
15294 
    return not (self == other)
15295 
 
15296 
class validateDoa_result:
15297 
  """
15298 
  Attributes:
15299 
   - success
15300 
   - ex
15301 
  """
15302 
 
15303 
  thrift_spec = (
15304 
    (0, TType.BOOL, 'success', None, None, ), # 0
15305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15306 
  )
15307 
 
15308 
  def __init__(self, success=None, ex=None,):
15309 
    self.success = success
15310 
    self.ex = ex
15311 
 
15312 
  def read(self, iprot):
15313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15315 
      return
15316 
    iprot.readStructBegin()
15317 
    while True:
15318 
      (fname, ftype, fid) = iprot.readFieldBegin()
15319 
      if ftype == TType.STOP:
15320 
        break
15321 
      if fid == 0:
15322 
        if ftype == TType.BOOL:
15323 
          self.success = iprot.readBool();
15324 
        else:
15325 
          iprot.skip(ftype)
15326 
      elif fid == 1:
15327 
        if ftype == TType.STRUCT:
15328 
          self.ex = TransactionServiceException()
15329 
          self.ex.read(iprot)
15330 
        else:
15331 
          iprot.skip(ftype)
15332 
      else:
15333 
        iprot.skip(ftype)
15334 
      iprot.readFieldEnd()
15335 
    iprot.readStructEnd()
15336 
 
15337 
  def write(self, oprot):
15338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15340 
      return
15341 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15342 
    if self.success is not None:
2591 chandransh 15343 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15344 
      oprot.writeBool(self.success)
15345 
      oprot.writeFieldEnd()
3431 rajveer 15346 
    if self.ex is not None:
2591 chandransh 15347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15348 
      self.ex.write(oprot)
15349 
      oprot.writeFieldEnd()
15350 
    oprot.writeFieldStop()
15351 
    oprot.writeStructEnd()
15352 
 
3431 rajveer 15353 
  def validate(self):
15354 
    return
15355 
 
15356 
 
2591 chandransh 15357 
  def __repr__(self):
15358 
    L = ['%s=%r' % (key, value)
15359 
      for key, value in self.__dict__.iteritems()]
15360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15361 
 
15362 
  def __eq__(self, other):
15363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15364 
 
15365 
  def __ne__(self, other):
15366 
    return not (self == other)
15367 
 
4495 rajveer 15368 
class validateReturnProduct_args:
15369 
  """
15370 
  Attributes:
15371 
   - orderId
15372 
   - isUsable
15373 
  """
15374 
 
15375 
  thrift_spec = (
15376 
    None, # 0
15377 
    (1, TType.I64, 'orderId', None, None, ), # 1
15378 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15379 
  )
15380 
 
15381 
  def __init__(self, orderId=None, isUsable=None,):
15382 
    self.orderId = orderId
15383 
    self.isUsable = isUsable
15384 
 
15385 
  def read(self, iprot):
15386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15388 
      return
15389 
    iprot.readStructBegin()
15390 
    while True:
15391 
      (fname, ftype, fid) = iprot.readFieldBegin()
15392 
      if ftype == TType.STOP:
15393 
        break
15394 
      if fid == 1:
15395 
        if ftype == TType.I64:
15396 
          self.orderId = iprot.readI64();
15397 
        else:
15398 
          iprot.skip(ftype)
15399 
      elif fid == 2:
15400 
        if ftype == TType.BOOL:
15401 
          self.isUsable = iprot.readBool();
15402 
        else:
15403 
          iprot.skip(ftype)
15404 
      else:
15405 
        iprot.skip(ftype)
15406 
      iprot.readFieldEnd()
15407 
    iprot.readStructEnd()
15408 
 
15409 
  def write(self, oprot):
15410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15412 
      return
15413 
    oprot.writeStructBegin('validateReturnProduct_args')
15414 
    if self.orderId is not None:
15415 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15416 
      oprot.writeI64(self.orderId)
15417 
      oprot.writeFieldEnd()
15418 
    if self.isUsable is not None:
15419 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15420 
      oprot.writeBool(self.isUsable)
15421 
      oprot.writeFieldEnd()
15422 
    oprot.writeFieldStop()
15423 
    oprot.writeStructEnd()
15424 
 
15425 
  def validate(self):
15426 
    return
15427 
 
15428 
 
15429 
  def __repr__(self):
15430 
    L = ['%s=%r' % (key, value)
15431 
      for key, value in self.__dict__.iteritems()]
15432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15433 
 
15434 
  def __eq__(self, other):
15435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15436 
 
15437 
  def __ne__(self, other):
15438 
    return not (self == other)
15439 
 
15440 
class validateReturnProduct_result:
15441 
  """
15442 
  Attributes:
15443 
   - success
15444 
   - ex
15445 
  """
15446 
 
15447 
  thrift_spec = (
15448 
    (0, TType.BOOL, 'success', None, None, ), # 0
15449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15450 
  )
15451 
 
15452 
  def __init__(self, success=None, ex=None,):
15453 
    self.success = success
15454 
    self.ex = ex
15455 
 
15456 
  def read(self, iprot):
15457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15459 
      return
15460 
    iprot.readStructBegin()
15461 
    while True:
15462 
      (fname, ftype, fid) = iprot.readFieldBegin()
15463 
      if ftype == TType.STOP:
15464 
        break
15465 
      if fid == 0:
15466 
        if ftype == TType.BOOL:
15467 
          self.success = iprot.readBool();
15468 
        else:
15469 
          iprot.skip(ftype)
15470 
      elif fid == 1:
15471 
        if ftype == TType.STRUCT:
15472 
          self.ex = TransactionServiceException()
15473 
          self.ex.read(iprot)
15474 
        else:
15475 
          iprot.skip(ftype)
15476 
      else:
15477 
        iprot.skip(ftype)
15478 
      iprot.readFieldEnd()
15479 
    iprot.readStructEnd()
15480 
 
15481 
  def write(self, oprot):
15482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15484 
      return
15485 
    oprot.writeStructBegin('validateReturnProduct_result')
15486 
    if self.success is not None:
15487 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15488 
      oprot.writeBool(self.success)
15489 
      oprot.writeFieldEnd()
15490 
    if self.ex is not None:
15491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15492 
      self.ex.write(oprot)
15493 
      oprot.writeFieldEnd()
15494 
    oprot.writeFieldStop()
15495 
    oprot.writeStructEnd()
15496 
 
15497 
  def validate(self):
15498 
    return
15499 
 
15500 
 
15501 
  def __repr__(self):
15502 
    L = ['%s=%r' % (key, value)
15503 
      for key, value in self.__dict__.iteritems()]
15504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15505 
 
15506 
  def __eq__(self, other):
15507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15508 
 
15509 
  def __ne__(self, other):
15510 
    return not (self == other)
15511 
 
2616 chandransh 15512 
class reshipOrder_args:
15513 
  """
15514 
  Attributes:
15515 
   - orderId
15516 
  """
2591 chandransh 15517 
 
2616 chandransh 15518 
  thrift_spec = (
15519 
    None, # 0
15520 
    (1, TType.I64, 'orderId', None, None, ), # 1
15521 
  )
15522 
 
15523 
  def __init__(self, orderId=None,):
15524 
    self.orderId = orderId
15525 
 
15526 
  def read(self, iprot):
15527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15529 
      return
15530 
    iprot.readStructBegin()
15531 
    while True:
15532 
      (fname, ftype, fid) = iprot.readFieldBegin()
15533 
      if ftype == TType.STOP:
15534 
        break
15535 
      if fid == 1:
15536 
        if ftype == TType.I64:
15537 
          self.orderId = iprot.readI64();
15538 
        else:
15539 
          iprot.skip(ftype)
15540 
      else:
15541 
        iprot.skip(ftype)
15542 
      iprot.readFieldEnd()
15543 
    iprot.readStructEnd()
15544 
 
15545 
  def write(self, oprot):
15546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15548 
      return
15549 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15550 
    if self.orderId is not None:
2616 chandransh 15551 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15552 
      oprot.writeI64(self.orderId)
15553 
      oprot.writeFieldEnd()
15554 
    oprot.writeFieldStop()
15555 
    oprot.writeStructEnd()
15556 
 
3431 rajveer 15557 
  def validate(self):
15558 
    return
15559 
 
15560 
 
2616 chandransh 15561 
  def __repr__(self):
15562 
    L = ['%s=%r' % (key, value)
15563 
      for key, value in self.__dict__.iteritems()]
15564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15565 
 
15566 
  def __eq__(self, other):
15567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15568 
 
15569 
  def __ne__(self, other):
15570 
    return not (self == other)
15571 
 
15572 
class reshipOrder_result:
15573 
  """
15574 
  Attributes:
15575 
   - success
15576 
   - ex
15577 
  """
15578 
 
15579 
  thrift_spec = (
15580 
    (0, TType.I64, 'success', None, None, ), # 0
15581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15582 
  )
15583 
 
15584 
  def __init__(self, success=None, ex=None,):
15585 
    self.success = success
15586 
    self.ex = ex
15587 
 
15588 
  def read(self, iprot):
15589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15591 
      return
15592 
    iprot.readStructBegin()
15593 
    while True:
15594 
      (fname, ftype, fid) = iprot.readFieldBegin()
15595 
      if ftype == TType.STOP:
15596 
        break
15597 
      if fid == 0:
15598 
        if ftype == TType.I64:
15599 
          self.success = iprot.readI64();
15600 
        else:
15601 
          iprot.skip(ftype)
15602 
      elif fid == 1:
15603 
        if ftype == TType.STRUCT:
15604 
          self.ex = TransactionServiceException()
15605 
          self.ex.read(iprot)
15606 
        else:
15607 
          iprot.skip(ftype)
15608 
      else:
15609 
        iprot.skip(ftype)
15610 
      iprot.readFieldEnd()
15611 
    iprot.readStructEnd()
15612 
 
15613 
  def write(self, oprot):
15614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15616 
      return
15617 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15618 
    if self.success is not None:
2616 chandransh 15619 
      oprot.writeFieldBegin('success', TType.I64, 0)
15620 
      oprot.writeI64(self.success)
15621 
      oprot.writeFieldEnd()
3431 rajveer 15622 
    if self.ex is not None:
2616 chandransh 15623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15624 
      self.ex.write(oprot)
15625 
      oprot.writeFieldEnd()
15626 
    oprot.writeFieldStop()
15627 
    oprot.writeStructEnd()
15628 
 
3431 rajveer 15629 
  def validate(self):
15630 
    return
15631 
 
15632 
 
2616 chandransh 15633 
  def __repr__(self):
15634 
    L = ['%s=%r' % (key, value)
15635 
      for key, value in self.__dict__.iteritems()]
15636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15637 
 
15638 
  def __eq__(self, other):
15639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15640 
 
15641 
  def __ne__(self, other):
15642 
    return not (self == other)
15643 
 
15644 
class refundOrder_args:
15645 
  """
15646 
  Attributes:
15647 
   - orderId
3226 chandransh 15648 
   - refundedBy
15649 
   - reason
2616 chandransh 15650 
  """
15651 
 
15652 
  thrift_spec = (
15653 
    None, # 0
15654 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15655 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15656 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15657 
  )
15658 
 
3226 chandransh 15659 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15660 
    self.orderId = orderId
3226 chandransh 15661 
    self.refundedBy = refundedBy
15662 
    self.reason = reason
2616 chandransh 15663 
 
15664 
  def read(self, iprot):
15665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15667 
      return
15668 
    iprot.readStructBegin()
15669 
    while True:
15670 
      (fname, ftype, fid) = iprot.readFieldBegin()
15671 
      if ftype == TType.STOP:
15672 
        break
15673 
      if fid == 1:
15674 
        if ftype == TType.I64:
15675 
          self.orderId = iprot.readI64();
15676 
        else:
15677 
          iprot.skip(ftype)
3226 chandransh 15678 
      elif fid == 2:
15679 
        if ftype == TType.STRING:
15680 
          self.refundedBy = iprot.readString();
15681 
        else:
15682 
          iprot.skip(ftype)
15683 
      elif fid == 3:
15684 
        if ftype == TType.STRING:
15685 
          self.reason = iprot.readString();
15686 
        else:
15687 
          iprot.skip(ftype)
2616 chandransh 15688 
      else:
15689 
        iprot.skip(ftype)
15690 
      iprot.readFieldEnd()
15691 
    iprot.readStructEnd()
15692 
 
15693 
  def write(self, oprot):
15694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15696 
      return
15697 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15698 
    if self.orderId is not None:
2616 chandransh 15699 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15700 
      oprot.writeI64(self.orderId)
15701 
      oprot.writeFieldEnd()
3431 rajveer 15702 
    if self.refundedBy is not None:
3226 chandransh 15703 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15704 
      oprot.writeString(self.refundedBy)
15705 
      oprot.writeFieldEnd()
3431 rajveer 15706 
    if self.reason is not None:
3226 chandransh 15707 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15708 
      oprot.writeString(self.reason)
15709 
      oprot.writeFieldEnd()
2616 chandransh 15710 
    oprot.writeFieldStop()
15711 
    oprot.writeStructEnd()
15712 
 
3431 rajveer 15713 
  def validate(self):
15714 
    return
15715 
 
15716 
 
2616 chandransh 15717 
  def __repr__(self):
15718 
    L = ['%s=%r' % (key, value)
15719 
      for key, value in self.__dict__.iteritems()]
15720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15721 
 
15722 
  def __eq__(self, other):
15723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15724 
 
15725 
  def __ne__(self, other):
15726 
    return not (self == other)
15727 
 
15728 
class refundOrder_result:
15729 
  """
15730 
  Attributes:
15731 
   - success
15732 
   - ex
15733 
  """
15734 
 
15735 
  thrift_spec = (
15736 
    (0, TType.BOOL, 'success', None, None, ), # 0
15737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15738 
  )
15739 
 
15740 
  def __init__(self, success=None, ex=None,):
15741 
    self.success = success
15742 
    self.ex = ex
15743 
 
15744 
  def read(self, iprot):
15745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15747 
      return
15748 
    iprot.readStructBegin()
15749 
    while True:
15750 
      (fname, ftype, fid) = iprot.readFieldBegin()
15751 
      if ftype == TType.STOP:
15752 
        break
15753 
      if fid == 0:
15754 
        if ftype == TType.BOOL:
15755 
          self.success = iprot.readBool();
15756 
        else:
15757 
          iprot.skip(ftype)
15758 
      elif fid == 1:
15759 
        if ftype == TType.STRUCT:
15760 
          self.ex = TransactionServiceException()
15761 
          self.ex.read(iprot)
15762 
        else:
15763 
          iprot.skip(ftype)
15764 
      else:
15765 
        iprot.skip(ftype)
15766 
      iprot.readFieldEnd()
15767 
    iprot.readStructEnd()
15768 
 
15769 
  def write(self, oprot):
15770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15772 
      return
15773 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15774 
    if self.success is not None:
2616 chandransh 15775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15776 
      oprot.writeBool(self.success)
15777 
      oprot.writeFieldEnd()
3431 rajveer 15778 
    if self.ex is not None:
2616 chandransh 15779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15780 
      self.ex.write(oprot)
15781 
      oprot.writeFieldEnd()
15782 
    oprot.writeFieldStop()
15783 
    oprot.writeStructEnd()
15784 
 
3431 rajveer 15785 
  def validate(self):
15786 
    return
15787 
 
15788 
 
2616 chandransh 15789 
  def __repr__(self):
15790 
    L = ['%s=%r' % (key, value)
15791 
      for key, value in self.__dict__.iteritems()]
15792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15793 
 
15794 
  def __eq__(self, other):
15795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15796 
 
15797 
  def __ne__(self, other):
15798 
    return not (self == other)
15799 
 
2690 chandransh 15800 
class getReturnOrders_args:
15801 
  """
15802 
  Attributes:
15803 
   - warehouseId
15804 
   - fromDate
15805 
   - toDate
15806 
  """
2616 chandransh 15807 
 
2690 chandransh 15808 
  thrift_spec = (
15809 
    None, # 0
15810 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15811 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15812 
    (3, TType.I64, 'toDate', None, None, ), # 3
15813 
  )
15814 
 
15815 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15816 
    self.warehouseId = warehouseId
15817 
    self.fromDate = fromDate
15818 
    self.toDate = toDate
15819 
 
15820 
  def read(self, iprot):
15821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15823 
      return
15824 
    iprot.readStructBegin()
15825 
    while True:
15826 
      (fname, ftype, fid) = iprot.readFieldBegin()
15827 
      if ftype == TType.STOP:
15828 
        break
15829 
      if fid == 1:
15830 
        if ftype == TType.I64:
15831 
          self.warehouseId = iprot.readI64();
15832 
        else:
15833 
          iprot.skip(ftype)
15834 
      elif fid == 2:
15835 
        if ftype == TType.I64:
15836 
          self.fromDate = iprot.readI64();
15837 
        else:
15838 
          iprot.skip(ftype)
15839 
      elif fid == 3:
15840 
        if ftype == TType.I64:
15841 
          self.toDate = iprot.readI64();
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      else:
15845 
        iprot.skip(ftype)
15846 
      iprot.readFieldEnd()
15847 
    iprot.readStructEnd()
15848 
 
15849 
  def write(self, oprot):
15850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15852 
      return
15853 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 15854 
    if self.warehouseId is not None:
2690 chandransh 15855 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15856 
      oprot.writeI64(self.warehouseId)
15857 
      oprot.writeFieldEnd()
3431 rajveer 15858 
    if self.fromDate is not None:
2690 chandransh 15859 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
15860 
      oprot.writeI64(self.fromDate)
15861 
      oprot.writeFieldEnd()
3431 rajveer 15862 
    if self.toDate is not None:
2690 chandransh 15863 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
15864 
      oprot.writeI64(self.toDate)
15865 
      oprot.writeFieldEnd()
15866 
    oprot.writeFieldStop()
15867 
    oprot.writeStructEnd()
15868 
 
3431 rajveer 15869 
  def validate(self):
15870 
    return
15871 
 
15872 
 
2690 chandransh 15873 
  def __repr__(self):
15874 
    L = ['%s=%r' % (key, value)
15875 
      for key, value in self.__dict__.iteritems()]
15876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15877 
 
15878 
  def __eq__(self, other):
15879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15880 
 
15881 
  def __ne__(self, other):
15882 
    return not (self == other)
15883 
 
15884 
class getReturnOrders_result:
15885 
  """
15886 
  Attributes:
15887 
   - success
15888 
  """
15889 
 
15890 
  thrift_spec = (
15891 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
15892 
  )
15893 
 
15894 
  def __init__(self, success=None,):
15895 
    self.success = success
15896 
 
15897 
  def read(self, iprot):
15898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15900 
      return
15901 
    iprot.readStructBegin()
15902 
    while True:
15903 
      (fname, ftype, fid) = iprot.readFieldBegin()
15904 
      if ftype == TType.STOP:
15905 
        break
15906 
      if fid == 0:
15907 
        if ftype == TType.LIST:
15908 
          self.success = []
4999 phani.kuma 15909 
          (_etype350, _size347) = iprot.readListBegin()
15910 
          for _i351 in xrange(_size347):
15911 
            _elem352 = ReturnOrder()
15912 
            _elem352.read(iprot)
15913 
            self.success.append(_elem352)
2690 chandransh 15914 
          iprot.readListEnd()
15915 
        else:
15916 
          iprot.skip(ftype)
15917 
      else:
15918 
        iprot.skip(ftype)
15919 
      iprot.readFieldEnd()
15920 
    iprot.readStructEnd()
15921 
 
15922 
  def write(self, oprot):
15923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15925 
      return
15926 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 15927 
    if self.success is not None:
2690 chandransh 15928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 15930 
      for iter353 in self.success:
15931 
        iter353.write(oprot)
2690 chandransh 15932 
      oprot.writeListEnd()
15933 
      oprot.writeFieldEnd()
15934 
    oprot.writeFieldStop()
15935 
    oprot.writeStructEnd()
15936 
 
3431 rajveer 15937 
  def validate(self):
15938 
    return
15939 
 
15940 
 
2690 chandransh 15941 
  def __repr__(self):
15942 
    L = ['%s=%r' % (key, value)
15943 
      for key, value in self.__dict__.iteritems()]
15944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15945 
 
15946 
  def __eq__(self, other):
15947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15948 
 
15949 
  def __ne__(self, other):
15950 
    return not (self == other)
15951 
 
2700 chandransh 15952 
class getReturnOrder_args:
15953 
  """
15954 
  Attributes:
15955 
   - id
15956 
  """
15957 
 
15958 
  thrift_spec = (
15959 
    None, # 0
15960 
    (1, TType.I64, 'id', None, None, ), # 1
15961 
  )
15962 
 
15963 
  def __init__(self, id=None,):
15964 
    self.id = id
15965 
 
15966 
  def read(self, iprot):
15967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15969 
      return
15970 
    iprot.readStructBegin()
15971 
    while True:
15972 
      (fname, ftype, fid) = iprot.readFieldBegin()
15973 
      if ftype == TType.STOP:
15974 
        break
15975 
      if fid == 1:
15976 
        if ftype == TType.I64:
15977 
          self.id = iprot.readI64();
15978 
        else:
15979 
          iprot.skip(ftype)
15980 
      else:
15981 
        iprot.skip(ftype)
15982 
      iprot.readFieldEnd()
15983 
    iprot.readStructEnd()
15984 
 
15985 
  def write(self, oprot):
15986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15988 
      return
15989 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 15990 
    if self.id is not None:
2700 chandransh 15991 
      oprot.writeFieldBegin('id', TType.I64, 1)
15992 
      oprot.writeI64(self.id)
15993 
      oprot.writeFieldEnd()
15994 
    oprot.writeFieldStop()
15995 
    oprot.writeStructEnd()
15996 
 
3431 rajveer 15997 
  def validate(self):
15998 
    return
15999 
 
16000 
 
2700 chandransh 16001 
  def __repr__(self):
16002 
    L = ['%s=%r' % (key, value)
16003 
      for key, value in self.__dict__.iteritems()]
16004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16005 
 
16006 
  def __eq__(self, other):
16007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16008 
 
16009 
  def __ne__(self, other):
16010 
    return not (self == other)
16011 
 
16012 
class getReturnOrder_result:
16013 
  """
16014 
  Attributes:
16015 
   - success
16016 
   - ex
16017 
  """
16018 
 
16019 
  thrift_spec = (
16020 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16022 
  )
16023 
 
16024 
  def __init__(self, success=None, ex=None,):
16025 
    self.success = success
16026 
    self.ex = ex
16027 
 
16028 
  def read(self, iprot):
16029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16031 
      return
16032 
    iprot.readStructBegin()
16033 
    while True:
16034 
      (fname, ftype, fid) = iprot.readFieldBegin()
16035 
      if ftype == TType.STOP:
16036 
        break
16037 
      if fid == 0:
16038 
        if ftype == TType.STRUCT:
16039 
          self.success = ReturnOrder()
16040 
          self.success.read(iprot)
16041 
        else:
16042 
          iprot.skip(ftype)
16043 
      elif fid == 1:
16044 
        if ftype == TType.STRUCT:
16045 
          self.ex = TransactionServiceException()
16046 
          self.ex.read(iprot)
16047 
        else:
16048 
          iprot.skip(ftype)
16049 
      else:
16050 
        iprot.skip(ftype)
16051 
      iprot.readFieldEnd()
16052 
    iprot.readStructEnd()
16053 
 
16054 
  def write(self, oprot):
16055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16057 
      return
16058 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16059 
    if self.success is not None:
2700 chandransh 16060 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16061 
      self.success.write(oprot)
16062 
      oprot.writeFieldEnd()
3431 rajveer 16063 
    if self.ex is not None:
2700 chandransh 16064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16065 
      self.ex.write(oprot)
16066 
      oprot.writeFieldEnd()
16067 
    oprot.writeFieldStop()
16068 
    oprot.writeStructEnd()
16069 
 
3431 rajveer 16070 
  def validate(self):
16071 
    return
16072 
 
16073 
 
2700 chandransh 16074 
  def __repr__(self):
16075 
    L = ['%s=%r' % (key, value)
16076 
      for key, value in self.__dict__.iteritems()]
16077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16078 
 
16079 
  def __eq__(self, other):
16080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16081 
 
16082 
  def __ne__(self, other):
16083 
    return not (self == other)
16084 
 
2690 chandransh 16085 
class processReturn_args:
16086 
  """
16087 
  Attributes:
16088 
   - returnOrderId
16089 
  """
16090 
 
16091 
  thrift_spec = (
16092 
    None, # 0
16093 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16094 
  )
16095 
 
16096 
  def __init__(self, returnOrderId=None,):
16097 
    self.returnOrderId = returnOrderId
16098 
 
16099 
  def read(self, iprot):
16100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16102 
      return
16103 
    iprot.readStructBegin()
16104 
    while True:
16105 
      (fname, ftype, fid) = iprot.readFieldBegin()
16106 
      if ftype == TType.STOP:
16107 
        break
16108 
      if fid == 1:
16109 
        if ftype == TType.I64:
16110 
          self.returnOrderId = iprot.readI64();
16111 
        else:
16112 
          iprot.skip(ftype)
16113 
      else:
16114 
        iprot.skip(ftype)
16115 
      iprot.readFieldEnd()
16116 
    iprot.readStructEnd()
16117 
 
16118 
  def write(self, oprot):
16119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16121 
      return
16122 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16123 
    if self.returnOrderId is not None:
2690 chandransh 16124 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16125 
      oprot.writeI64(self.returnOrderId)
16126 
      oprot.writeFieldEnd()
16127 
    oprot.writeFieldStop()
16128 
    oprot.writeStructEnd()
16129 
 
3431 rajveer 16130 
  def validate(self):
16131 
    return
16132 
 
16133 
 
2690 chandransh 16134 
  def __repr__(self):
16135 
    L = ['%s=%r' % (key, value)
16136 
      for key, value in self.__dict__.iteritems()]
16137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16138 
 
16139 
  def __eq__(self, other):
16140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16141 
 
16142 
  def __ne__(self, other):
16143 
    return not (self == other)
16144 
 
16145 
class processReturn_result:
16146 
  """
16147 
  Attributes:
16148 
   - ex
16149 
  """
16150 
 
16151 
  thrift_spec = (
16152 
    None, # 0
16153 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16154 
  )
16155 
 
16156 
  def __init__(self, ex=None,):
16157 
    self.ex = ex
16158 
 
16159 
  def read(self, iprot):
16160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16162 
      return
16163 
    iprot.readStructBegin()
16164 
    while True:
16165 
      (fname, ftype, fid) = iprot.readFieldBegin()
16166 
      if ftype == TType.STOP:
16167 
        break
16168 
      if fid == 1:
16169 
        if ftype == TType.STRUCT:
16170 
          self.ex = TransactionServiceException()
16171 
          self.ex.read(iprot)
16172 
        else:
16173 
          iprot.skip(ftype)
16174 
      else:
16175 
        iprot.skip(ftype)
16176 
      iprot.readFieldEnd()
16177 
    iprot.readStructEnd()
16178 
 
16179 
  def write(self, oprot):
16180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16182 
      return
16183 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16184 
    if self.ex is not None:
2690 chandransh 16185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16186 
      self.ex.write(oprot)
16187 
      oprot.writeFieldEnd()
16188 
    oprot.writeFieldStop()
16189 
    oprot.writeStructEnd()
16190 
 
3431 rajveer 16191 
  def validate(self):
16192 
    return
16193 
 
16194 
 
2690 chandransh 16195 
  def __repr__(self):
16196 
    L = ['%s=%r' % (key, value)
16197 
      for key, value in self.__dict__.iteritems()]
16198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16199 
 
16200 
  def __eq__(self, other):
16201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16202 
 
16203 
  def __ne__(self, other):
16204 
    return not (self == other)
16205 
 
3451 chandransh 16206 
class updateWeight_args:
16207 
  """
16208 
  Attributes:
16209 
   - orderId
16210 
   - weight
16211 
  """
16212 
 
16213 
  thrift_spec = (
16214 
    None, # 0
16215 
    (1, TType.I64, 'orderId', None, None, ), # 1
16216 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16217 
  )
16218 
 
16219 
  def __init__(self, orderId=None, weight=None,):
16220 
    self.orderId = orderId
16221 
    self.weight = weight
16222 
 
16223 
  def read(self, iprot):
16224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16226 
      return
16227 
    iprot.readStructBegin()
16228 
    while True:
16229 
      (fname, ftype, fid) = iprot.readFieldBegin()
16230 
      if ftype == TType.STOP:
16231 
        break
16232 
      if fid == 1:
16233 
        if ftype == TType.I64:
16234 
          self.orderId = iprot.readI64();
16235 
        else:
16236 
          iprot.skip(ftype)
16237 
      elif fid == 2:
16238 
        if ftype == TType.DOUBLE:
16239 
          self.weight = iprot.readDouble();
16240 
        else:
16241 
          iprot.skip(ftype)
16242 
      else:
16243 
        iprot.skip(ftype)
16244 
      iprot.readFieldEnd()
16245 
    iprot.readStructEnd()
16246 
 
16247 
  def write(self, oprot):
16248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16250 
      return
16251 
    oprot.writeStructBegin('updateWeight_args')
16252 
    if self.orderId is not None:
16253 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16254 
      oprot.writeI64(self.orderId)
16255 
      oprot.writeFieldEnd()
16256 
    if self.weight is not None:
16257 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16258 
      oprot.writeDouble(self.weight)
16259 
      oprot.writeFieldEnd()
16260 
    oprot.writeFieldStop()
16261 
    oprot.writeStructEnd()
16262 
 
16263 
  def validate(self):
16264 
    return
16265 
 
16266 
 
16267 
  def __repr__(self):
16268 
    L = ['%s=%r' % (key, value)
16269 
      for key, value in self.__dict__.iteritems()]
16270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16271 
 
16272 
  def __eq__(self, other):
16273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16274 
 
16275 
  def __ne__(self, other):
16276 
    return not (self == other)
16277 
 
16278 
class updateWeight_result:
16279 
  """
16280 
  Attributes:
16281 
   - success
16282 
   - ex
16283 
  """
16284 
 
16285 
  thrift_spec = (
16286 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16288 
  )
16289 
 
16290 
  def __init__(self, success=None, ex=None,):
16291 
    self.success = success
16292 
    self.ex = ex
16293 
 
16294 
  def read(self, iprot):
16295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16297 
      return
16298 
    iprot.readStructBegin()
16299 
    while True:
16300 
      (fname, ftype, fid) = iprot.readFieldBegin()
16301 
      if ftype == TType.STOP:
16302 
        break
16303 
      if fid == 0:
16304 
        if ftype == TType.STRUCT:
16305 
          self.success = Order()
16306 
          self.success.read(iprot)
16307 
        else:
16308 
          iprot.skip(ftype)
16309 
      elif fid == 1:
16310 
        if ftype == TType.STRUCT:
16311 
          self.ex = TransactionServiceException()
16312 
          self.ex.read(iprot)
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      else:
16316 
        iprot.skip(ftype)
16317 
      iprot.readFieldEnd()
16318 
    iprot.readStructEnd()
16319 
 
16320 
  def write(self, oprot):
16321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16323 
      return
16324 
    oprot.writeStructBegin('updateWeight_result')
16325 
    if self.success is not None:
16326 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16327 
      self.success.write(oprot)
16328 
      oprot.writeFieldEnd()
16329 
    if self.ex is not None:
16330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16331 
      self.ex.write(oprot)
16332 
      oprot.writeFieldEnd()
16333 
    oprot.writeFieldStop()
16334 
    oprot.writeStructEnd()
16335 
 
16336 
  def validate(self):
16337 
    return
16338 
 
16339 
 
16340 
  def __repr__(self):
16341 
    L = ['%s=%r' % (key, value)
16342 
      for key, value in self.__dict__.iteritems()]
16343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16344 
 
16345 
  def __eq__(self, other):
16346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16347 
 
16348 
  def __ne__(self, other):
16349 
    return not (self == other)
3469 chandransh 16350 
 
16351 
class changeItem_args:
16352 
  """
16353 
  Attributes:
16354 
   - orderId
16355 
   - itemId
16356 
  """
16357 
 
16358 
  thrift_spec = (
16359 
    None, # 0
16360 
    (1, TType.I64, 'orderId', None, None, ), # 1
16361 
    (2, TType.I64, 'itemId', None, None, ), # 2
16362 
  )
16363 
 
16364 
  def __init__(self, orderId=None, itemId=None,):
16365 
    self.orderId = orderId
16366 
    self.itemId = itemId
16367 
 
16368 
  def read(self, iprot):
16369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16371 
      return
16372 
    iprot.readStructBegin()
16373 
    while True:
16374 
      (fname, ftype, fid) = iprot.readFieldBegin()
16375 
      if ftype == TType.STOP:
16376 
        break
16377 
      if fid == 1:
16378 
        if ftype == TType.I64:
16379 
          self.orderId = iprot.readI64();
16380 
        else:
16381 
          iprot.skip(ftype)
16382 
      elif fid == 2:
16383 
        if ftype == TType.I64:
16384 
          self.itemId = iprot.readI64();
16385 
        else:
16386 
          iprot.skip(ftype)
16387 
      else:
16388 
        iprot.skip(ftype)
16389 
      iprot.readFieldEnd()
16390 
    iprot.readStructEnd()
16391 
 
16392 
  def write(self, oprot):
16393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16395 
      return
16396 
    oprot.writeStructBegin('changeItem_args')
16397 
    if self.orderId is not None:
16398 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16399 
      oprot.writeI64(self.orderId)
16400 
      oprot.writeFieldEnd()
16401 
    if self.itemId is not None:
16402 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16403 
      oprot.writeI64(self.itemId)
16404 
      oprot.writeFieldEnd()
16405 
    oprot.writeFieldStop()
16406 
    oprot.writeStructEnd()
16407 
 
16408 
  def validate(self):
16409 
    return
16410 
 
16411 
 
16412 
  def __repr__(self):
16413 
    L = ['%s=%r' % (key, value)
16414 
      for key, value in self.__dict__.iteritems()]
16415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16416 
 
16417 
  def __eq__(self, other):
16418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16419 
 
16420 
  def __ne__(self, other):
16421 
    return not (self == other)
16422 
 
16423 
class changeItem_result:
16424 
  """
16425 
  Attributes:
16426 
   - success
16427 
   - ex
16428 
  """
16429 
 
16430 
  thrift_spec = (
16431 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16433 
  )
16434 
 
16435 
  def __init__(self, success=None, ex=None,):
16436 
    self.success = success
16437 
    self.ex = ex
16438 
 
16439 
  def read(self, iprot):
16440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16442 
      return
16443 
    iprot.readStructBegin()
16444 
    while True:
16445 
      (fname, ftype, fid) = iprot.readFieldBegin()
16446 
      if ftype == TType.STOP:
16447 
        break
16448 
      if fid == 0:
16449 
        if ftype == TType.STRUCT:
16450 
          self.success = Order()
16451 
          self.success.read(iprot)
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      elif fid == 1:
16455 
        if ftype == TType.STRUCT:
16456 
          self.ex = TransactionServiceException()
16457 
          self.ex.read(iprot)
16458 
        else:
16459 
          iprot.skip(ftype)
16460 
      else:
16461 
        iprot.skip(ftype)
16462 
      iprot.readFieldEnd()
16463 
    iprot.readStructEnd()
16464 
 
16465 
  def write(self, oprot):
16466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16468 
      return
16469 
    oprot.writeStructBegin('changeItem_result')
16470 
    if self.success is not None:
16471 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16472 
      self.success.write(oprot)
16473 
      oprot.writeFieldEnd()
16474 
    if self.ex is not None:
16475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16476 
      self.ex.write(oprot)
16477 
      oprot.writeFieldEnd()
16478 
    oprot.writeFieldStop()
16479 
    oprot.writeStructEnd()
16480 
 
16481 
  def validate(self):
16482 
    return
16483 
 
16484 
 
16485 
  def __repr__(self):
16486 
    L = ['%s=%r' % (key, value)
16487 
      for key, value in self.__dict__.iteritems()]
16488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16489 
 
16490 
  def __eq__(self, other):
16491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16492 
 
16493 
  def __ne__(self, other):
16494 
    return not (self == other)
16495 
 
16496 
class shiftToWarehouse_args:
16497 
  """
16498 
  Attributes:
16499 
   - orderId
16500 
   - warehouseId
16501 
  """
16502 
 
16503 
  thrift_spec = (
16504 
    None, # 0
16505 
    (1, TType.I64, 'orderId', None, None, ), # 1
16506 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16507 
  )
16508 
 
16509 
  def __init__(self, orderId=None, warehouseId=None,):
16510 
    self.orderId = orderId
16511 
    self.warehouseId = warehouseId
16512 
 
16513 
  def read(self, iprot):
16514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16516 
      return
16517 
    iprot.readStructBegin()
16518 
    while True:
16519 
      (fname, ftype, fid) = iprot.readFieldBegin()
16520 
      if ftype == TType.STOP:
16521 
        break
16522 
      if fid == 1:
16523 
        if ftype == TType.I64:
16524 
          self.orderId = iprot.readI64();
16525 
        else:
16526 
          iprot.skip(ftype)
16527 
      elif fid == 2:
16528 
        if ftype == TType.I64:
16529 
          self.warehouseId = iprot.readI64();
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('shiftToWarehouse_args')
16542 
    if self.orderId is not None:
16543 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16544 
      oprot.writeI64(self.orderId)
16545 
      oprot.writeFieldEnd()
16546 
    if self.warehouseId is not None:
16547 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16548 
      oprot.writeI64(self.warehouseId)
16549 
      oprot.writeFieldEnd()
16550 
    oprot.writeFieldStop()
16551 
    oprot.writeStructEnd()
16552 
 
16553 
  def validate(self):
16554 
    return
16555 
 
16556 
 
16557 
  def __repr__(self):
16558 
    L = ['%s=%r' % (key, value)
16559 
      for key, value in self.__dict__.iteritems()]
16560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16561 
 
16562 
  def __eq__(self, other):
16563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16564 
 
16565 
  def __ne__(self, other):
16566 
    return not (self == other)
16567 
 
16568 
class shiftToWarehouse_result:
16569 
  """
16570 
  Attributes:
16571 
   - success
16572 
   - ex
16573 
  """
16574 
 
16575 
  thrift_spec = (
16576 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16578 
  )
16579 
 
16580 
  def __init__(self, success=None, ex=None,):
16581 
    self.success = success
16582 
    self.ex = ex
16583 
 
16584 
  def read(self, iprot):
16585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16587 
      return
16588 
    iprot.readStructBegin()
16589 
    while True:
16590 
      (fname, ftype, fid) = iprot.readFieldBegin()
16591 
      if ftype == TType.STOP:
16592 
        break
16593 
      if fid == 0:
16594 
        if ftype == TType.STRUCT:
16595 
          self.success = Order()
16596 
          self.success.read(iprot)
16597 
        else:
16598 
          iprot.skip(ftype)
16599 
      elif fid == 1:
16600 
        if ftype == TType.STRUCT:
16601 
          self.ex = TransactionServiceException()
16602 
          self.ex.read(iprot)
16603 
        else:
16604 
          iprot.skip(ftype)
16605 
      else:
16606 
        iprot.skip(ftype)
16607 
      iprot.readFieldEnd()
16608 
    iprot.readStructEnd()
16609 
 
16610 
  def write(self, oprot):
16611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16613 
      return
16614 
    oprot.writeStructBegin('shiftToWarehouse_result')
16615 
    if self.success is not None:
16616 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16617 
      self.success.write(oprot)
16618 
      oprot.writeFieldEnd()
16619 
    if self.ex is not None:
16620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16621 
      self.ex.write(oprot)
16622 
      oprot.writeFieldEnd()
16623 
    oprot.writeFieldStop()
16624 
    oprot.writeStructEnd()
16625 
 
16626 
  def validate(self):
16627 
    return
16628 
 
16629 
 
16630 
  def __repr__(self):
16631 
    L = ['%s=%r' % (key, value)
16632 
      for key, value in self.__dict__.iteritems()]
16633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16634 
 
16635 
  def __eq__(self, other):
16636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16637 
 
16638 
  def __ne__(self, other):
16639 
    return not (self == other)
3553 chandransh 16640 
 
16641 
class addDelayReason_args:
16642 
  """
16643 
  Attributes:
16644 
   - orderId
16645 
   - delayReason
3986 chandransh 16646 
   - furtherDelay
4647 rajveer 16647 
   - delayReasonText
3553 chandransh 16648 
  """
16649 
 
16650 
  thrift_spec = (
16651 
    None, # 0
16652 
    (1, TType.I64, 'orderId', None, None, ), # 1
16653 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16654 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16655 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16656 
  )
16657 
 
4647 rajveer 16658 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16659 
    self.orderId = orderId
16660 
    self.delayReason = delayReason
3986 chandransh 16661 
    self.furtherDelay = furtherDelay
4647 rajveer 16662 
    self.delayReasonText = delayReasonText
3553 chandransh 16663 
 
16664 
  def read(self, iprot):
16665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16667 
      return
16668 
    iprot.readStructBegin()
16669 
    while True:
16670 
      (fname, ftype, fid) = iprot.readFieldBegin()
16671 
      if ftype == TType.STOP:
16672 
        break
16673 
      if fid == 1:
16674 
        if ftype == TType.I64:
16675 
          self.orderId = iprot.readI64();
16676 
        else:
16677 
          iprot.skip(ftype)
16678 
      elif fid == 2:
16679 
        if ftype == TType.I32:
16680 
          self.delayReason = iprot.readI32();
16681 
        else:
16682 
          iprot.skip(ftype)
3986 chandransh 16683 
      elif fid == 3:
16684 
        if ftype == TType.I64:
16685 
          self.furtherDelay = iprot.readI64();
16686 
        else:
16687 
          iprot.skip(ftype)
4647 rajveer 16688 
      elif fid == 4:
16689 
        if ftype == TType.STRING:
16690 
          self.delayReasonText = iprot.readString();
16691 
        else:
16692 
          iprot.skip(ftype)
3553 chandransh 16693 
      else:
16694 
        iprot.skip(ftype)
16695 
      iprot.readFieldEnd()
16696 
    iprot.readStructEnd()
16697 
 
16698 
  def write(self, oprot):
16699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16701 
      return
16702 
    oprot.writeStructBegin('addDelayReason_args')
16703 
    if self.orderId is not None:
16704 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16705 
      oprot.writeI64(self.orderId)
16706 
      oprot.writeFieldEnd()
16707 
    if self.delayReason is not None:
16708 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16709 
      oprot.writeI32(self.delayReason)
16710 
      oprot.writeFieldEnd()
3986 chandransh 16711 
    if self.furtherDelay is not None:
16712 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16713 
      oprot.writeI64(self.furtherDelay)
16714 
      oprot.writeFieldEnd()
4647 rajveer 16715 
    if self.delayReasonText is not None:
16716 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16717 
      oprot.writeString(self.delayReasonText)
16718 
      oprot.writeFieldEnd()
3553 chandransh 16719 
    oprot.writeFieldStop()
16720 
    oprot.writeStructEnd()
16721 
 
16722 
  def validate(self):
16723 
    return
16724 
 
16725 
 
16726 
  def __repr__(self):
16727 
    L = ['%s=%r' % (key, value)
16728 
      for key, value in self.__dict__.iteritems()]
16729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16730 
 
16731 
  def __eq__(self, other):
16732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16733 
 
16734 
  def __ne__(self, other):
16735 
    return not (self == other)
16736 
 
16737 
class addDelayReason_result:
16738 
  """
16739 
  Attributes:
16740 
   - success
16741 
   - ex
16742 
  """
16743 
 
16744 
  thrift_spec = (
16745 
    (0, TType.BOOL, 'success', None, None, ), # 0
16746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16747 
  )
16748 
 
16749 
  def __init__(self, success=None, ex=None,):
16750 
    self.success = success
16751 
    self.ex = ex
16752 
 
16753 
  def read(self, iprot):
16754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16756 
      return
16757 
    iprot.readStructBegin()
16758 
    while True:
16759 
      (fname, ftype, fid) = iprot.readFieldBegin()
16760 
      if ftype == TType.STOP:
16761 
        break
16762 
      if fid == 0:
16763 
        if ftype == TType.BOOL:
16764 
          self.success = iprot.readBool();
16765 
        else:
16766 
          iprot.skip(ftype)
16767 
      elif fid == 1:
16768 
        if ftype == TType.STRUCT:
16769 
          self.ex = TransactionServiceException()
16770 
          self.ex.read(iprot)
16771 
        else:
16772 
          iprot.skip(ftype)
16773 
      else:
16774 
        iprot.skip(ftype)
16775 
      iprot.readFieldEnd()
16776 
    iprot.readStructEnd()
16777 
 
16778 
  def write(self, oprot):
16779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16781 
      return
16782 
    oprot.writeStructBegin('addDelayReason_result')
16783 
    if self.success is not None:
16784 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16785 
      oprot.writeBool(self.success)
16786 
      oprot.writeFieldEnd()
16787 
    if self.ex is not None:
16788 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16789 
      self.ex.write(oprot)
16790 
      oprot.writeFieldEnd()
16791 
    oprot.writeFieldStop()
16792 
    oprot.writeStructEnd()
16793 
 
16794 
  def validate(self):
16795 
    return
16796 
 
16797 
 
16798 
  def __repr__(self):
16799 
    L = ['%s=%r' % (key, value)
16800 
      for key, value in self.__dict__.iteritems()]
16801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16802 
 
16803 
  def __eq__(self, other):
16804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16805 
 
16806 
  def __ne__(self, other):
16807 
    return not (self == other)
3956 chandransh 16808 
 
16809 
class reconcileCodCollection_args:
16810 
  """
16811 
  Attributes:
16812 
   - collectedAmountMap
16813 
   - xferBy
16814 
   - xferTxnId
16815 
   - xferDate
16816 
  """
16817 
 
16818 
  thrift_spec = (
16819 
    None, # 0
16820 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16821 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16822 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16823 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16824 
  )
16825 
 
16826 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16827 
    self.collectedAmountMap = collectedAmountMap
16828 
    self.xferBy = xferBy
16829 
    self.xferTxnId = xferTxnId
16830 
    self.xferDate = xferDate
16831 
 
16832 
  def read(self, iprot):
16833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16835 
      return
16836 
    iprot.readStructBegin()
16837 
    while True:
16838 
      (fname, ftype, fid) = iprot.readFieldBegin()
16839 
      if ftype == TType.STOP:
16840 
        break
16841 
      if fid == 1:
16842 
        if ftype == TType.MAP:
16843 
          self.collectedAmountMap = {}
4999 phani.kuma 16844 
          (_ktype355, _vtype356, _size354 ) = iprot.readMapBegin()
16845 
          for _i358 in xrange(_size354):
16846 
            _key359 = iprot.readString();
16847 
            _val360 = iprot.readDouble();
16848 
            self.collectedAmountMap[_key359] = _val360
3956 chandransh 16849 
          iprot.readMapEnd()
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      elif fid == 2:
16853 
        if ftype == TType.STRING:
16854 
          self.xferBy = iprot.readString();
16855 
        else:
16856 
          iprot.skip(ftype)
16857 
      elif fid == 3:
16858 
        if ftype == TType.STRING:
16859 
          self.xferTxnId = iprot.readString();
16860 
        else:
16861 
          iprot.skip(ftype)
16862 
      elif fid == 4:
16863 
        if ftype == TType.I64:
16864 
          self.xferDate = iprot.readI64();
16865 
        else:
16866 
          iprot.skip(ftype)
16867 
      else:
16868 
        iprot.skip(ftype)
16869 
      iprot.readFieldEnd()
16870 
    iprot.readStructEnd()
16871 
 
16872 
  def write(self, oprot):
16873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16875 
      return
16876 
    oprot.writeStructBegin('reconcileCodCollection_args')
16877 
    if self.collectedAmountMap is not None:
16878 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
16879 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4999 phani.kuma 16880 
      for kiter361,viter362 in self.collectedAmountMap.items():
16881 
        oprot.writeString(kiter361)
16882 
        oprot.writeDouble(viter362)
3956 chandransh 16883 
      oprot.writeMapEnd()
16884 
      oprot.writeFieldEnd()
16885 
    if self.xferBy is not None:
16886 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
16887 
      oprot.writeString(self.xferBy)
16888 
      oprot.writeFieldEnd()
16889 
    if self.xferTxnId is not None:
16890 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
16891 
      oprot.writeString(self.xferTxnId)
16892 
      oprot.writeFieldEnd()
16893 
    if self.xferDate is not None:
16894 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
16895 
      oprot.writeI64(self.xferDate)
16896 
      oprot.writeFieldEnd()
16897 
    oprot.writeFieldStop()
16898 
    oprot.writeStructEnd()
16899 
 
16900 
  def validate(self):
16901 
    return
16902 
 
16903 
 
16904 
  def __repr__(self):
16905 
    L = ['%s=%r' % (key, value)
16906 
      for key, value in self.__dict__.iteritems()]
16907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16908 
 
16909 
  def __eq__(self, other):
16910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16911 
 
16912 
  def __ne__(self, other):
16913 
    return not (self == other)
16914 
 
16915 
class reconcileCodCollection_result:
16916 
  """
16917 
  Attributes:
16918 
   - success
16919 
   - ex
16920 
  """
16921 
 
16922 
  thrift_spec = (
16923 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16925 
  )
16926 
 
16927 
  def __init__(self, success=None, ex=None,):
16928 
    self.success = success
16929 
    self.ex = ex
16930 
 
16931 
  def read(self, iprot):
16932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16934 
      return
16935 
    iprot.readStructBegin()
16936 
    while True:
16937 
      (fname, ftype, fid) = iprot.readFieldBegin()
16938 
      if ftype == TType.STOP:
16939 
        break
16940 
      if fid == 0:
16941 
        if ftype == TType.MAP:
16942 
          self.success = {}
4999 phani.kuma 16943 
          (_ktype364, _vtype365, _size363 ) = iprot.readMapBegin()
16944 
          for _i367 in xrange(_size363):
16945 
            _key368 = iprot.readString();
16946 
            _val369 = iprot.readString();
16947 
            self.success[_key368] = _val369
3956 chandransh 16948 
          iprot.readMapEnd()
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      elif fid == 1:
16952 
        if ftype == TType.STRUCT:
16953 
          self.ex = TransactionServiceException()
16954 
          self.ex.read(iprot)
16955 
        else:
16956 
          iprot.skip(ftype)
16957 
      else:
16958 
        iprot.skip(ftype)
16959 
      iprot.readFieldEnd()
16960 
    iprot.readStructEnd()
16961 
 
16962 
  def write(self, oprot):
16963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16965 
      return
16966 
    oprot.writeStructBegin('reconcileCodCollection_result')
16967 
    if self.success is not None:
16968 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16969 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4999 phani.kuma 16970 
      for kiter370,viter371 in self.success.items():
16971 
        oprot.writeString(kiter370)
16972 
        oprot.writeString(viter371)
3956 chandransh 16973 
      oprot.writeMapEnd()
16974 
      oprot.writeFieldEnd()
16975 
    if self.ex is not None:
16976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16977 
      self.ex.write(oprot)
16978 
      oprot.writeFieldEnd()
16979 
    oprot.writeFieldStop()
16980 
    oprot.writeStructEnd()
16981 
 
16982 
  def validate(self):
16983 
    return
16984 
 
16985 
 
16986 
  def __repr__(self):
16987 
    L = ['%s=%r' % (key, value)
16988 
      for key, value in self.__dict__.iteritems()]
16989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16990 
 
16991 
  def __eq__(self, other):
16992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16993 
 
16994 
  def __ne__(self, other):
16995 
    return not (self == other)
4008 mandeep.dh 16996 
 
16997 
class getTransactionsRequiringExtraProcessing_args:
16998 
  """
16999 
  Attributes:
17000 
   - category
17001 
  """
17002 
 
17003 
  thrift_spec = (
17004 
    None, # 0
17005 
    (1, TType.I32, 'category', None, None, ), # 1
17006 
  )
17007 
 
17008 
  def __init__(self, category=None,):
17009 
    self.category = category
17010 
 
17011 
  def read(self, iprot):
17012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17014 
      return
17015 
    iprot.readStructBegin()
17016 
    while True:
17017 
      (fname, ftype, fid) = iprot.readFieldBegin()
17018 
      if ftype == TType.STOP:
17019 
        break
17020 
      if fid == 1:
17021 
        if ftype == TType.I32:
17022 
          self.category = iprot.readI32();
17023 
        else:
17024 
          iprot.skip(ftype)
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('getTransactionsRequiringExtraProcessing_args')
17035 
    if self.category is not None:
17036 
      oprot.writeFieldBegin('category', TType.I32, 1)
17037 
      oprot.writeI32(self.category)
17038 
      oprot.writeFieldEnd()
17039 
    oprot.writeFieldStop()
17040 
    oprot.writeStructEnd()
17041 
 
17042 
  def validate(self):
17043 
    return
17044 
 
17045 
 
17046 
  def __repr__(self):
17047 
    L = ['%s=%r' % (key, value)
17048 
      for key, value in self.__dict__.iteritems()]
17049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17050 
 
17051 
  def __eq__(self, other):
17052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17053 
 
17054 
  def __ne__(self, other):
17055 
    return not (self == other)
17056 
 
17057 
class getTransactionsRequiringExtraProcessing_result:
17058 
  """
17059 
  Attributes:
17060 
   - success
17061 
  """
17062 
 
17063 
  thrift_spec = (
17064 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17065 
  )
17066 
 
17067 
  def __init__(self, success=None,):
17068 
    self.success = success
17069 
 
17070 
  def read(self, iprot):
17071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17073 
      return
17074 
    iprot.readStructBegin()
17075 
    while True:
17076 
      (fname, ftype, fid) = iprot.readFieldBegin()
17077 
      if ftype == TType.STOP:
17078 
        break
17079 
      if fid == 0:
17080 
        if ftype == TType.LIST:
17081 
          self.success = []
4999 phani.kuma 17082 
          (_etype375, _size372) = iprot.readListBegin()
17083 
          for _i376 in xrange(_size372):
17084 
            _elem377 = iprot.readI64();
17085 
            self.success.append(_elem377)
4008 mandeep.dh 17086 
          iprot.readListEnd()
17087 
        else:
17088 
          iprot.skip(ftype)
17089 
      else:
17090 
        iprot.skip(ftype)
17091 
      iprot.readFieldEnd()
17092 
    iprot.readStructEnd()
17093 
 
17094 
  def write(self, oprot):
17095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17097 
      return
17098 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17099 
    if self.success is not None:
17100 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17101 
      oprot.writeListBegin(TType.I64, len(self.success))
4999 phani.kuma 17102 
      for iter378 in self.success:
17103 
        oprot.writeI64(iter378)
4008 mandeep.dh 17104 
      oprot.writeListEnd()
17105 
      oprot.writeFieldEnd()
17106 
    oprot.writeFieldStop()
17107 
    oprot.writeStructEnd()
17108 
 
17109 
  def validate(self):
17110 
    return
17111 
 
17112 
 
17113 
  def __repr__(self):
17114 
    L = ['%s=%r' % (key, value)
17115 
      for key, value in self.__dict__.iteritems()]
17116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17117 
 
17118 
  def __eq__(self, other):
17119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17120 
 
17121 
  def __ne__(self, other):
17122 
    return not (self == other)
17123 
 
17124 
class markTransactionAsProcessed_args:
17125 
  """
17126 
  Attributes:
17127 
   - transactionId
17128 
   - category
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    None, # 0
17133 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17134 
    (2, TType.I32, 'category', None, None, ), # 2
17135 
  )
17136 
 
17137 
  def __init__(self, transactionId=None, category=None,):
17138 
    self.transactionId = transactionId
17139 
    self.category = category
17140 
 
17141 
  def read(self, iprot):
17142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17144 
      return
17145 
    iprot.readStructBegin()
17146 
    while True:
17147 
      (fname, ftype, fid) = iprot.readFieldBegin()
17148 
      if ftype == TType.STOP:
17149 
        break
17150 
      if fid == 1:
17151 
        if ftype == TType.I64:
17152 
          self.transactionId = iprot.readI64();
17153 
        else:
17154 
          iprot.skip(ftype)
17155 
      elif fid == 2:
17156 
        if ftype == TType.I32:
17157 
          self.category = iprot.readI32();
17158 
        else:
17159 
          iprot.skip(ftype)
17160 
      else:
17161 
        iprot.skip(ftype)
17162 
      iprot.readFieldEnd()
17163 
    iprot.readStructEnd()
17164 
 
17165 
  def write(self, oprot):
17166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17168 
      return
17169 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17170 
    if self.transactionId is not None:
17171 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17172 
      oprot.writeI64(self.transactionId)
17173 
      oprot.writeFieldEnd()
17174 
    if self.category is not None:
17175 
      oprot.writeFieldBegin('category', TType.I32, 2)
17176 
      oprot.writeI32(self.category)
17177 
      oprot.writeFieldEnd()
17178 
    oprot.writeFieldStop()
17179 
    oprot.writeStructEnd()
17180 
 
17181 
  def validate(self):
17182 
    return
17183 
 
17184 
 
17185 
  def __repr__(self):
17186 
    L = ['%s=%r' % (key, value)
17187 
      for key, value in self.__dict__.iteritems()]
17188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17189 
 
17190 
  def __eq__(self, other):
17191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17192 
 
17193 
  def __ne__(self, other):
17194 
    return not (self == other)
17195 
 
17196 
class markTransactionAsProcessed_result:
17197 
 
17198 
  thrift_spec = (
17199 
  )
17200 
 
17201 
  def read(self, iprot):
17202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17204 
      return
17205 
    iprot.readStructBegin()
17206 
    while True:
17207 
      (fname, ftype, fid) = iprot.readFieldBegin()
17208 
      if ftype == TType.STOP:
17209 
        break
17210 
      else:
17211 
        iprot.skip(ftype)
17212 
      iprot.readFieldEnd()
17213 
    iprot.readStructEnd()
17214 
 
17215 
  def write(self, oprot):
17216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17218 
      return
17219 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17220 
    oprot.writeFieldStop()
17221 
    oprot.writeStructEnd()
17222 
 
17223 
  def validate(self):
17224 
    return
17225 
 
17226 
 
17227 
  def __repr__(self):
17228 
    L = ['%s=%r' % (key, value)
17229 
      for key, value in self.__dict__.iteritems()]
17230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17231 
 
17232 
  def __eq__(self, other):
17233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17234 
 
17235 
  def __ne__(self, other):
17236 
    return not (self == other)
4018 chandransh 17237 
 
17238 
class getItemWiseRiskyOrdersCount_args:
17239 
 
17240 
  thrift_spec = (
17241 
  )
17242 
 
17243 
  def read(self, iprot):
17244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17246 
      return
17247 
    iprot.readStructBegin()
17248 
    while True:
17249 
      (fname, ftype, fid) = iprot.readFieldBegin()
17250 
      if ftype == TType.STOP:
17251 
        break
17252 
      else:
17253 
        iprot.skip(ftype)
17254 
      iprot.readFieldEnd()
17255 
    iprot.readStructEnd()
17256 
 
17257 
  def write(self, oprot):
17258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17260 
      return
17261 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17262 
    oprot.writeFieldStop()
17263 
    oprot.writeStructEnd()
17264 
 
17265 
  def validate(self):
17266 
    return
17267 
 
17268 
 
17269 
  def __repr__(self):
17270 
    L = ['%s=%r' % (key, value)
17271 
      for key, value in self.__dict__.iteritems()]
17272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17273 
 
17274 
  def __eq__(self, other):
17275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17276 
 
17277 
  def __ne__(self, other):
17278 
    return not (self == other)
17279 
 
17280 
class getItemWiseRiskyOrdersCount_result:
17281 
  """
17282 
  Attributes:
17283 
   - success
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17288 
  )
17289 
 
17290 
  def __init__(self, success=None,):
17291 
    self.success = success
17292 
 
17293 
  def read(self, iprot):
17294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17296 
      return
17297 
    iprot.readStructBegin()
17298 
    while True:
17299 
      (fname, ftype, fid) = iprot.readFieldBegin()
17300 
      if ftype == TType.STOP:
17301 
        break
17302 
      if fid == 0:
17303 
        if ftype == TType.MAP:
17304 
          self.success = {}
4999 phani.kuma 17305 
          (_ktype380, _vtype381, _size379 ) = iprot.readMapBegin()
17306 
          for _i383 in xrange(_size379):
17307 
            _key384 = iprot.readI64();
17308 
            _val385 = iprot.readI64();
17309 
            self.success[_key384] = _val385
4018 chandransh 17310 
          iprot.readMapEnd()
17311 
        else:
17312 
          iprot.skip(ftype)
17313 
      else:
17314 
        iprot.skip(ftype)
17315 
      iprot.readFieldEnd()
17316 
    iprot.readStructEnd()
17317 
 
17318 
  def write(self, oprot):
17319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17321 
      return
17322 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17323 
    if self.success is not None:
17324 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17325 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4999 phani.kuma 17326 
      for kiter386,viter387 in self.success.items():
17327 
        oprot.writeI64(kiter386)
17328 
        oprot.writeI64(viter387)
4018 chandransh 17329 
      oprot.writeMapEnd()
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
4247 rajveer 17348 
 
4295 varun.gupt 17349 
class getOrdersForItemIds_args:
17350 
  """
17351 
  Attributes:
17352 
   - itemIds
17353 
  """
17354 
 
17355 
  thrift_spec = (
17356 
    None, # 0
17357 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17358 
  )
17359 
 
17360 
  def __init__(self, itemIds=None,):
17361 
    self.itemIds = itemIds
17362 
 
17363 
  def read(self, iprot):
17364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17366 
      return
17367 
    iprot.readStructBegin()
17368 
    while True:
17369 
      (fname, ftype, fid) = iprot.readFieldBegin()
17370 
      if ftype == TType.STOP:
17371 
        break
17372 
      if fid == 1:
17373 
        if ftype == TType.LIST:
17374 
          self.itemIds = []
4999 phani.kuma 17375 
          (_etype391, _size388) = iprot.readListBegin()
17376 
          for _i392 in xrange(_size388):
17377 
            _elem393 = iprot.readI64();
17378 
            self.itemIds.append(_elem393)
4295 varun.gupt 17379 
          iprot.readListEnd()
17380 
        else:
17381 
          iprot.skip(ftype)
17382 
      else:
17383 
        iprot.skip(ftype)
17384 
      iprot.readFieldEnd()
17385 
    iprot.readStructEnd()
17386 
 
17387 
  def write(self, oprot):
17388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17390 
      return
17391 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17392 
    if self.itemIds is not None:
17393 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17394 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4999 phani.kuma 17395 
      for iter394 in self.itemIds:
17396 
        oprot.writeI64(iter394)
4295 varun.gupt 17397 
      oprot.writeListEnd()
17398 
      oprot.writeFieldEnd()
17399 
    oprot.writeFieldStop()
17400 
    oprot.writeStructEnd()
17401 
 
17402 
  def validate(self):
17403 
    return
17404 
 
17405 
 
17406 
  def __repr__(self):
17407 
    L = ['%s=%r' % (key, value)
17408 
      for key, value in self.__dict__.iteritems()]
17409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17410 
 
17411 
  def __eq__(self, other):
17412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17413 
 
17414 
  def __ne__(self, other):
17415 
    return not (self == other)
17416 
 
17417 
class getOrdersForItemIds_result:
17418 
  """
17419 
  Attributes:
17420 
   - success
17421 
  """
17422 
 
17423 
  thrift_spec = (
17424 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17425 
  )
17426 
 
17427 
  def __init__(self, success=None,):
17428 
    self.success = success
17429 
 
17430 
  def read(self, iprot):
17431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17433 
      return
17434 
    iprot.readStructBegin()
17435 
    while True:
17436 
      (fname, ftype, fid) = iprot.readFieldBegin()
17437 
      if ftype == TType.STOP:
17438 
        break
17439 
      if fid == 0:
17440 
        if ftype == TType.LIST:
17441 
          self.success = []
4999 phani.kuma 17442 
          (_etype398, _size395) = iprot.readListBegin()
17443 
          for _i399 in xrange(_size395):
17444 
            _elem400 = Order()
17445 
            _elem400.read(iprot)
17446 
            self.success.append(_elem400)
4295 varun.gupt 17447 
          iprot.readListEnd()
17448 
        else:
17449 
          iprot.skip(ftype)
17450 
      else:
17451 
        iprot.skip(ftype)
17452 
      iprot.readFieldEnd()
17453 
    iprot.readStructEnd()
17454 
 
17455 
  def write(self, oprot):
17456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17458 
      return
17459 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17460 
    if self.success is not None:
17461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 17463 
      for iter401 in self.success:
17464 
        iter401.write(oprot)
4295 varun.gupt 17465 
      oprot.writeListEnd()
17466 
      oprot.writeFieldEnd()
17467 
    oprot.writeFieldStop()
17468 
    oprot.writeStructEnd()
17469 
 
17470 
  def validate(self):
17471 
    return
17472 
 
17473 
 
17474 
  def __repr__(self):
17475 
    L = ['%s=%r' % (key, value)
17476 
      for key, value in self.__dict__.iteritems()]
17477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17478 
 
17479 
  def __eq__(self, other):
17480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17481 
 
17482 
  def __ne__(self, other):
17483 
    return not (self == other)
17484 
 
4247 rajveer 17485 
class markOrderCancellationRequestReceived_args:
17486 
  """
17487 
  Attributes:
17488 
   - orderId
17489 
  """
17490 
 
17491 
  thrift_spec = (
17492 
    None, # 0
17493 
    (1, TType.I64, 'orderId', None, None, ), # 1
17494 
  )
17495 
 
17496 
  def __init__(self, orderId=None,):
17497 
    self.orderId = orderId
17498 
 
17499 
  def read(self, iprot):
17500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17502 
      return
17503 
    iprot.readStructBegin()
17504 
    while True:
17505 
      (fname, ftype, fid) = iprot.readFieldBegin()
17506 
      if ftype == TType.STOP:
17507 
        break
17508 
      if fid == 1:
17509 
        if ftype == TType.I64:
17510 
          self.orderId = iprot.readI64();
17511 
        else:
17512 
          iprot.skip(ftype)
17513 
      else:
17514 
        iprot.skip(ftype)
17515 
      iprot.readFieldEnd()
17516 
    iprot.readStructEnd()
17517 
 
17518 
  def write(self, oprot):
17519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17521 
      return
17522 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17523 
    if self.orderId is not None:
17524 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17525 
      oprot.writeI64(self.orderId)
17526 
      oprot.writeFieldEnd()
17527 
    oprot.writeFieldStop()
17528 
    oprot.writeStructEnd()
17529 
 
17530 
  def validate(self):
17531 
    return
17532 
 
17533 
 
17534 
  def __repr__(self):
17535 
    L = ['%s=%r' % (key, value)
17536 
      for key, value in self.__dict__.iteritems()]
17537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17538 
 
17539 
  def __eq__(self, other):
17540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17541 
 
17542 
  def __ne__(self, other):
17543 
    return not (self == other)
17544 
 
17545 
class markOrderCancellationRequestReceived_result:
17546 
  """
17547 
  Attributes:
17548 
   - ex
17549 
  """
17550 
 
17551 
  thrift_spec = (
17552 
    None, # 0
17553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17554 
  )
17555 
 
17556 
  def __init__(self, ex=None,):
17557 
    self.ex = ex
17558 
 
17559 
  def read(self, iprot):
17560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17562 
      return
17563 
    iprot.readStructBegin()
17564 
    while True:
17565 
      (fname, ftype, fid) = iprot.readFieldBegin()
17566 
      if ftype == TType.STOP:
17567 
        break
17568 
      if fid == 1:
17569 
        if ftype == TType.STRUCT:
17570 
          self.ex = TransactionServiceException()
17571 
          self.ex.read(iprot)
17572 
        else:
17573 
          iprot.skip(ftype)
17574 
      else:
17575 
        iprot.skip(ftype)
17576 
      iprot.readFieldEnd()
17577 
    iprot.readStructEnd()
17578 
 
17579 
  def write(self, oprot):
17580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17582 
      return
17583 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17584 
    if self.ex is not None:
17585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17586 
      self.ex.write(oprot)
17587 
      oprot.writeFieldEnd()
17588 
    oprot.writeFieldStop()
17589 
    oprot.writeStructEnd()
17590 
 
17591 
  def validate(self):
17592 
    return
17593 
 
17594 
 
17595 
  def __repr__(self):
17596 
    L = ['%s=%r' % (key, value)
17597 
      for key, value in self.__dict__.iteritems()]
17598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17599 
 
17600 
  def __eq__(self, other):
17601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17602 
 
17603 
  def __ne__(self, other):
17604 
    return not (self == other)
17605 
 
17606 
class markOrderCancellationRequestConfirmed_args:
17607 
  """
17608 
  Attributes:
17609 
   - orderId
17610 
  """
17611 
 
17612 
  thrift_spec = (
17613 
    None, # 0
17614 
    (1, TType.I64, 'orderId', None, None, ), # 1
17615 
  )
17616 
 
17617 
  def __init__(self, orderId=None,):
17618 
    self.orderId = orderId
17619 
 
17620 
  def read(self, iprot):
17621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17623 
      return
17624 
    iprot.readStructBegin()
17625 
    while True:
17626 
      (fname, ftype, fid) = iprot.readFieldBegin()
17627 
      if ftype == TType.STOP:
17628 
        break
17629 
      if fid == 1:
17630 
        if ftype == TType.I64:
17631 
          self.orderId = iprot.readI64();
17632 
        else:
17633 
          iprot.skip(ftype)
17634 
      else:
17635 
        iprot.skip(ftype)
17636 
      iprot.readFieldEnd()
17637 
    iprot.readStructEnd()
17638 
 
17639 
  def write(self, oprot):
17640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17642 
      return
17643 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17644 
    if self.orderId is not None:
17645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17646 
      oprot.writeI64(self.orderId)
17647 
      oprot.writeFieldEnd()
17648 
    oprot.writeFieldStop()
17649 
    oprot.writeStructEnd()
17650 
 
17651 
  def validate(self):
17652 
    return
17653 
 
17654 
 
17655 
  def __repr__(self):
17656 
    L = ['%s=%r' % (key, value)
17657 
      for key, value in self.__dict__.iteritems()]
17658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17659 
 
17660 
  def __eq__(self, other):
17661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17662 
 
17663 
  def __ne__(self, other):
17664 
    return not (self == other)
17665 
 
17666 
class markOrderCancellationRequestConfirmed_result:
17667 
  """
17668 
  Attributes:
17669 
   - ex
17670 
  """
17671 
 
17672 
  thrift_spec = (
17673 
    None, # 0
17674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17675 
  )
17676 
 
17677 
  def __init__(self, ex=None,):
17678 
    self.ex = ex
17679 
 
17680 
  def read(self, iprot):
17681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17683 
      return
17684 
    iprot.readStructBegin()
17685 
    while True:
17686 
      (fname, ftype, fid) = iprot.readFieldBegin()
17687 
      if ftype == TType.STOP:
17688 
        break
17689 
      if fid == 1:
17690 
        if ftype == TType.STRUCT:
17691 
          self.ex = TransactionServiceException()
17692 
          self.ex.read(iprot)
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      else:
17696 
        iprot.skip(ftype)
17697 
      iprot.readFieldEnd()
17698 
    iprot.readStructEnd()
17699 
 
17700 
  def write(self, oprot):
17701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17703 
      return
17704 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17705 
    if self.ex is not None:
17706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17707 
      self.ex.write(oprot)
17708 
      oprot.writeFieldEnd()
17709 
    oprot.writeFieldStop()
17710 
    oprot.writeStructEnd()
17711 
 
17712 
  def validate(self):
17713 
    return
17714 
 
17715 
 
17716 
  def __repr__(self):
17717 
    L = ['%s=%r' % (key, value)
17718 
      for key, value in self.__dict__.iteritems()]
17719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17720 
 
17721 
  def __eq__(self, other):
17722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17723 
 
17724 
  def __ne__(self, other):
17725 
    return not (self == other)
17726 
 
17727 
class markOrderCancellationRequestDenied_args:
17728 
  """
17729 
  Attributes:
17730 
   - orderId
17731 
  """
17732 
 
17733 
  thrift_spec = (
17734 
    None, # 0
17735 
    (1, TType.I64, 'orderId', None, None, ), # 1
17736 
  )
17737 
 
17738 
  def __init__(self, orderId=None,):
17739 
    self.orderId = orderId
17740 
 
17741 
  def read(self, iprot):
17742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17744 
      return
17745 
    iprot.readStructBegin()
17746 
    while True:
17747 
      (fname, ftype, fid) = iprot.readFieldBegin()
17748 
      if ftype == TType.STOP:
17749 
        break
17750 
      if fid == 1:
17751 
        if ftype == TType.I64:
17752 
          self.orderId = iprot.readI64();
17753 
        else:
17754 
          iprot.skip(ftype)
17755 
      else:
17756 
        iprot.skip(ftype)
17757 
      iprot.readFieldEnd()
17758 
    iprot.readStructEnd()
17759 
 
17760 
  def write(self, oprot):
17761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17763 
      return
17764 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17765 
    if self.orderId is not None:
17766 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17767 
      oprot.writeI64(self.orderId)
17768 
      oprot.writeFieldEnd()
17769 
    oprot.writeFieldStop()
17770 
    oprot.writeStructEnd()
17771 
 
17772 
  def validate(self):
17773 
    return
17774 
 
17775 
 
17776 
  def __repr__(self):
17777 
    L = ['%s=%r' % (key, value)
17778 
      for key, value in self.__dict__.iteritems()]
17779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17780 
 
17781 
  def __eq__(self, other):
17782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17783 
 
17784 
  def __ne__(self, other):
17785 
    return not (self == other)
17786 
 
17787 
class markOrderCancellationRequestDenied_result:
17788 
  """
17789 
  Attributes:
17790 
   - ex
17791 
  """
17792 
 
17793 
  thrift_spec = (
17794 
    None, # 0
17795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17796 
  )
17797 
 
17798 
  def __init__(self, ex=None,):
17799 
    self.ex = ex
17800 
 
17801 
  def read(self, iprot):
17802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17804 
      return
17805 
    iprot.readStructBegin()
17806 
    while True:
17807 
      (fname, ftype, fid) = iprot.readFieldBegin()
17808 
      if ftype == TType.STOP:
17809 
        break
17810 
      if fid == 1:
17811 
        if ftype == TType.STRUCT:
17812 
          self.ex = TransactionServiceException()
17813 
          self.ex.read(iprot)
17814 
        else:
17815 
          iprot.skip(ftype)
17816 
      else:
17817 
        iprot.skip(ftype)
17818 
      iprot.readFieldEnd()
17819 
    iprot.readStructEnd()
17820 
 
17821 
  def write(self, oprot):
17822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17824 
      return
17825 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17826 
    if self.ex is not None:
17827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17828 
      self.ex.write(oprot)
17829 
      oprot.writeFieldEnd()
17830 
    oprot.writeFieldStop()
17831 
    oprot.writeStructEnd()
17832 
 
17833 
  def validate(self):
17834 
    return
17835 
 
17836 
 
17837 
  def __repr__(self):
17838 
    L = ['%s=%r' % (key, value)
17839 
      for key, value in self.__dict__.iteritems()]
17840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17841 
 
17842 
  def __eq__(self, other):
17843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17844 
 
17845 
  def __ne__(self, other):
17846 
    return not (self == other)
17847 
 
4258 rajveer 17848 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 17849 
  """
17850 
  Attributes:
4258 rajveer 17851 
   - transactionId
4247 rajveer 17852 
  """
17853 
 
17854 
  thrift_spec = (
17855 
    None, # 0
4258 rajveer 17856 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 17857 
  )
17858 
 
4258 rajveer 17859 
  def __init__(self, transactionId=None,):
17860 
    self.transactionId = transactionId
4247 rajveer 17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      if fid == 1:
17872 
        if ftype == TType.I64:
4258 rajveer 17873 
          self.transactionId = iprot.readI64();
4247 rajveer 17874 
        else:
17875 
          iprot.skip(ftype)
17876 
      else:
17877 
        iprot.skip(ftype)
17878 
      iprot.readFieldEnd()
17879 
    iprot.readStructEnd()
17880 
 
17881 
  def write(self, oprot):
17882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17884 
      return
4258 rajveer 17885 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
17886 
    if self.transactionId is not None:
17887 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17888 
      oprot.writeI64(self.transactionId)
4247 rajveer 17889 
      oprot.writeFieldEnd()
17890 
    oprot.writeFieldStop()
17891 
    oprot.writeStructEnd()
17892 
 
17893 
  def validate(self):
17894 
    return
17895 
 
17896 
 
17897 
  def __repr__(self):
17898 
    L = ['%s=%r' % (key, value)
17899 
      for key, value in self.__dict__.iteritems()]
17900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17901 
 
17902 
  def __eq__(self, other):
17903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17904 
 
17905 
  def __ne__(self, other):
17906 
    return not (self == other)
17907 
 
4258 rajveer 17908 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 17909 
  """
17910 
  Attributes:
17911 
   - ex
17912 
  """
17913 
 
17914 
  thrift_spec = (
17915 
    None, # 0
17916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17917 
  )
17918 
 
17919 
  def __init__(self, ex=None,):
17920 
    self.ex = ex
17921 
 
17922 
  def read(self, iprot):
17923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17925 
      return
17926 
    iprot.readStructBegin()
17927 
    while True:
17928 
      (fname, ftype, fid) = iprot.readFieldBegin()
17929 
      if ftype == TType.STOP:
17930 
        break
17931 
      if fid == 1:
17932 
        if ftype == TType.STRUCT:
17933 
          self.ex = TransactionServiceException()
17934 
          self.ex.read(iprot)
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      else:
17938 
        iprot.skip(ftype)
17939 
      iprot.readFieldEnd()
17940 
    iprot.readStructEnd()
17941 
 
17942 
  def write(self, oprot):
17943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17945 
      return
4258 rajveer 17946 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 17947 
    if self.ex is not None:
17948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17949 
      self.ex.write(oprot)
17950 
      oprot.writeFieldEnd()
17951 
    oprot.writeFieldStop()
17952 
    oprot.writeStructEnd()
17953 
 
17954 
  def validate(self):
17955 
    return
17956 
 
17957 
 
17958 
  def __repr__(self):
17959 
    L = ['%s=%r' % (key, value)
17960 
      for key, value in self.__dict__.iteritems()]
17961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17962 
 
17963 
  def __eq__(self, other):
17964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17965 
 
17966 
  def __ne__(self, other):
17967 
    return not (self == other)
4259 anupam.sin 17968 
 
17969 
class refundTransaction_args:
17970 
  """
17971 
  Attributes:
17972 
   - transactionId
17973 
   - refundedBy
17974 
   - reason
17975 
  """
17976 
 
17977 
  thrift_spec = (
17978 
    None, # 0
17979 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17980 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17981 
    (3, TType.STRING, 'reason', None, None, ), # 3
17982 
  )
17983 
 
17984 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
17985 
    self.transactionId = transactionId
17986 
    self.refundedBy = refundedBy
17987 
    self.reason = reason
17988 
 
17989 
  def read(self, iprot):
17990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17992 
      return
17993 
    iprot.readStructBegin()
17994 
    while True:
17995 
      (fname, ftype, fid) = iprot.readFieldBegin()
17996 
      if ftype == TType.STOP:
17997 
        break
17998 
      if fid == 1:
17999 
        if ftype == TType.I64:
18000 
          self.transactionId = iprot.readI64();
18001 
        else:
18002 
          iprot.skip(ftype)
18003 
      elif fid == 2:
18004 
        if ftype == TType.STRING:
18005 
          self.refundedBy = iprot.readString();
18006 
        else:
18007 
          iprot.skip(ftype)
18008 
      elif fid == 3:
18009 
        if ftype == TType.STRING:
18010 
          self.reason = iprot.readString();
18011 
        else:
18012 
          iprot.skip(ftype)
18013 
      else:
18014 
        iprot.skip(ftype)
18015 
      iprot.readFieldEnd()
18016 
    iprot.readStructEnd()
18017 
 
18018 
  def write(self, oprot):
18019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18021 
      return
18022 
    oprot.writeStructBegin('refundTransaction_args')
18023 
    if self.transactionId is not None:
18024 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18025 
      oprot.writeI64(self.transactionId)
18026 
      oprot.writeFieldEnd()
18027 
    if self.refundedBy is not None:
18028 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18029 
      oprot.writeString(self.refundedBy)
18030 
      oprot.writeFieldEnd()
18031 
    if self.reason is not None:
18032 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18033 
      oprot.writeString(self.reason)
18034 
      oprot.writeFieldEnd()
18035 
    oprot.writeFieldStop()
18036 
    oprot.writeStructEnd()
18037 
 
18038 
  def validate(self):
18039 
    return
18040 
 
18041 
 
18042 
  def __repr__(self):
18043 
    L = ['%s=%r' % (key, value)
18044 
      for key, value in self.__dict__.iteritems()]
18045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18046 
 
18047 
  def __eq__(self, other):
18048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18049 
 
18050 
  def __ne__(self, other):
18051 
    return not (self == other)
18052 
 
18053 
class refundTransaction_result:
18054 
  """
18055 
  Attributes:
18056 
   - ex
18057 
  """
18058 
 
18059 
  thrift_spec = (
18060 
    None, # 0
18061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18062 
  )
18063 
 
18064 
  def __init__(self, ex=None,):
18065 
    self.ex = ex
18066 
 
18067 
  def read(self, iprot):
18068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18070 
      return
18071 
    iprot.readStructBegin()
18072 
    while True:
18073 
      (fname, ftype, fid) = iprot.readFieldBegin()
18074 
      if ftype == TType.STOP:
18075 
        break
18076 
      if fid == 1:
18077 
        if ftype == TType.STRUCT:
18078 
          self.ex = TransactionServiceException()
18079 
          self.ex.read(iprot)
18080 
        else:
18081 
          iprot.skip(ftype)
18082 
      else:
18083 
        iprot.skip(ftype)
18084 
      iprot.readFieldEnd()
18085 
    iprot.readStructEnd()
18086 
 
18087 
  def write(self, oprot):
18088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18090 
      return
18091 
    oprot.writeStructBegin('refundTransaction_result')
18092 
    if self.ex is not None:
18093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18094 
      self.ex.write(oprot)
18095 
      oprot.writeFieldEnd()
18096 
    oprot.writeFieldStop()
18097 
    oprot.writeStructEnd()
18098 
 
18099 
  def validate(self):
18100 
    return
18101 
 
18102 
 
18103 
  def __repr__(self):
18104 
    L = ['%s=%r' % (key, value)
18105 
      for key, value in self.__dict__.iteritems()]
18106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18107 
 
18108 
  def __eq__(self, other):
18109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18110 
 
18111 
  def __ne__(self, other):
18112 
    return not (self == other)
4285 rajveer 18113 
 
4324 mandeep.dh 18114 
class updateShipmentAddress_args:
18115 
  """
18116 
  Attributes:
18117 
   - orderId
18118 
   - addressId
18119 
  """
18120 
 
18121 
  thrift_spec = (
18122 
    None, # 0
18123 
    (1, TType.I64, 'orderId', None, None, ), # 1
18124 
    (2, TType.I64, 'addressId', None, None, ), # 2
18125 
  )
18126 
 
18127 
  def __init__(self, orderId=None, addressId=None,):
18128 
    self.orderId = orderId
18129 
    self.addressId = addressId
18130 
 
18131 
  def read(self, iprot):
18132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18134 
      return
18135 
    iprot.readStructBegin()
18136 
    while True:
18137 
      (fname, ftype, fid) = iprot.readFieldBegin()
18138 
      if ftype == TType.STOP:
18139 
        break
18140 
      if fid == 1:
18141 
        if ftype == TType.I64:
18142 
          self.orderId = iprot.readI64();
18143 
        else:
18144 
          iprot.skip(ftype)
18145 
      elif fid == 2:
18146 
        if ftype == TType.I64:
18147 
          self.addressId = iprot.readI64();
18148 
        else:
18149 
          iprot.skip(ftype)
18150 
      else:
18151 
        iprot.skip(ftype)
18152 
      iprot.readFieldEnd()
18153 
    iprot.readStructEnd()
18154 
 
18155 
  def write(self, oprot):
18156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18158 
      return
18159 
    oprot.writeStructBegin('updateShipmentAddress_args')
18160 
    if self.orderId is not None:
18161 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18162 
      oprot.writeI64(self.orderId)
18163 
      oprot.writeFieldEnd()
18164 
    if self.addressId is not None:
18165 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18166 
      oprot.writeI64(self.addressId)
18167 
      oprot.writeFieldEnd()
18168 
    oprot.writeFieldStop()
18169 
    oprot.writeStructEnd()
18170 
 
18171 
  def validate(self):
18172 
    return
18173 
 
18174 
 
18175 
  def __repr__(self):
18176 
    L = ['%s=%r' % (key, value)
18177 
      for key, value in self.__dict__.iteritems()]
18178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18179 
 
18180 
  def __eq__(self, other):
18181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18182 
 
18183 
  def __ne__(self, other):
18184 
    return not (self == other)
18185 
 
18186 
class updateShipmentAddress_result:
18187 
  """
18188 
  Attributes:
18189 
   - ex
18190 
  """
18191 
 
18192 
  thrift_spec = (
18193 
    None, # 0
18194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18195 
  )
18196 
 
18197 
  def __init__(self, ex=None,):
18198 
    self.ex = ex
18199 
 
18200 
  def read(self, iprot):
18201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18203 
      return
18204 
    iprot.readStructBegin()
18205 
    while True:
18206 
      (fname, ftype, fid) = iprot.readFieldBegin()
18207 
      if ftype == TType.STOP:
18208 
        break
18209 
      if fid == 1:
18210 
        if ftype == TType.STRUCT:
18211 
          self.ex = TransactionServiceException()
18212 
          self.ex.read(iprot)
18213 
        else:
18214 
          iprot.skip(ftype)
18215 
      else:
18216 
        iprot.skip(ftype)
18217 
      iprot.readFieldEnd()
18218 
    iprot.readStructEnd()
18219 
 
18220 
  def write(self, oprot):
18221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18223 
      return
18224 
    oprot.writeStructBegin('updateShipmentAddress_result')
18225 
    if self.ex is not None:
18226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18227 
      self.ex.write(oprot)
18228 
      oprot.writeFieldEnd()
18229 
    oprot.writeFieldStop()
18230 
    oprot.writeStructEnd()
18231 
 
18232 
  def validate(self):
18233 
    return
18234 
 
18235 
 
18236 
  def __repr__(self):
18237 
    L = ['%s=%r' % (key, value)
18238 
      for key, value in self.__dict__.iteritems()]
18239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18240 
 
18241 
  def __eq__(self, other):
18242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18243 
 
18244 
  def __ne__(self, other):
18245 
    return not (self == other)
18246 
 
4285 rajveer 18247 
class acceptOrdersForItemId_args:
18248 
  """
18249 
  Attributes:
18250 
   - itemId
18251 
   - inventory
18252 
  """
18253 
 
18254 
  thrift_spec = (
18255 
    None, # 0
18256 
    (1, TType.I64, 'itemId', None, None, ), # 1
18257 
    (2, TType.I64, 'inventory', None, None, ), # 2
18258 
  )
18259 
 
18260 
  def __init__(self, itemId=None, inventory=None,):
18261 
    self.itemId = itemId
18262 
    self.inventory = inventory
18263 
 
18264 
  def read(self, iprot):
18265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18267 
      return
18268 
    iprot.readStructBegin()
18269 
    while True:
18270 
      (fname, ftype, fid) = iprot.readFieldBegin()
18271 
      if ftype == TType.STOP:
18272 
        break
18273 
      if fid == 1:
18274 
        if ftype == TType.I64:
18275 
          self.itemId = iprot.readI64();
18276 
        else:
18277 
          iprot.skip(ftype)
18278 
      elif fid == 2:
18279 
        if ftype == TType.I64:
18280 
          self.inventory = iprot.readI64();
18281 
        else:
18282 
          iprot.skip(ftype)
18283 
      else:
18284 
        iprot.skip(ftype)
18285 
      iprot.readFieldEnd()
18286 
    iprot.readStructEnd()
18287 
 
18288 
  def write(self, oprot):
18289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18291 
      return
18292 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18293 
    if self.itemId is not None:
18294 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18295 
      oprot.writeI64(self.itemId)
18296 
      oprot.writeFieldEnd()
18297 
    if self.inventory is not None:
18298 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18299 
      oprot.writeI64(self.inventory)
18300 
      oprot.writeFieldEnd()
18301 
    oprot.writeFieldStop()
18302 
    oprot.writeStructEnd()
18303 
 
18304 
  def validate(self):
18305 
    return
18306 
 
18307 
 
18308 
  def __repr__(self):
18309 
    L = ['%s=%r' % (key, value)
18310 
      for key, value in self.__dict__.iteritems()]
18311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18312 
 
18313 
  def __eq__(self, other):
18314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18315 
 
18316 
  def __ne__(self, other):
18317 
    return not (self == other)
18318 
 
18319 
class acceptOrdersForItemId_result:
18320 
  """
18321 
  Attributes:
18322 
   - success
18323 
   - ex
18324 
  """
18325 
 
18326 
  thrift_spec = (
18327 
    (0, TType.BOOL, 'success', None, None, ), # 0
18328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18329 
  )
18330 
 
18331 
  def __init__(self, success=None, ex=None,):
18332 
    self.success = success
18333 
    self.ex = ex
18334 
 
18335 
  def read(self, iprot):
18336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18338 
      return
18339 
    iprot.readStructBegin()
18340 
    while True:
18341 
      (fname, ftype, fid) = iprot.readFieldBegin()
18342 
      if ftype == TType.STOP:
18343 
        break
18344 
      if fid == 0:
18345 
        if ftype == TType.BOOL:
18346 
          self.success = iprot.readBool();
18347 
        else:
18348 
          iprot.skip(ftype)
18349 
      elif fid == 1:
18350 
        if ftype == TType.STRUCT:
18351 
          self.ex = TransactionServiceException()
18352 
          self.ex.read(iprot)
18353 
        else:
18354 
          iprot.skip(ftype)
18355 
      else:
18356 
        iprot.skip(ftype)
18357 
      iprot.readFieldEnd()
18358 
    iprot.readStructEnd()
18359 
 
18360 
  def write(self, oprot):
18361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18363 
      return
18364 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18365 
    if self.success is not None:
18366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18367 
      oprot.writeBool(self.success)
18368 
      oprot.writeFieldEnd()
18369 
    if self.ex is not None:
18370 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18371 
      self.ex.write(oprot)
18372 
      oprot.writeFieldEnd()
18373 
    oprot.writeFieldStop()
18374 
    oprot.writeStructEnd()
18375 
 
18376 
  def validate(self):
18377 
    return
18378 
 
18379 
 
18380 
  def __repr__(self):
18381 
    L = ['%s=%r' % (key, value)
18382 
      for key, value in self.__dict__.iteritems()]
18383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18384 
 
18385 
  def __eq__(self, other):
18386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18387 
 
18388 
  def __ne__(self, other):
18389 
    return not (self == other)
4303 rajveer 18390 
 
18391 
class markOrdersAsPORaised_args:
18392 
  """
18393 
  Attributes:
18394 
   - vendorId
18395 
   - itemId
18396 
   - quantity
18397 
   - estimate
4369 rajveer 18398 
   - isReminder
4303 rajveer 18399 
  """
18400 
 
18401 
  thrift_spec = (
18402 
    None, # 0
18403 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18404 
    (2, TType.I64, 'itemId', None, None, ), # 2
18405 
    (3, TType.I64, 'quantity', None, None, ), # 3
18406 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18407 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18408 
  )
18409 
 
4369 rajveer 18410 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18411 
    self.vendorId = vendorId
18412 
    self.itemId = itemId
18413 
    self.quantity = quantity
18414 
    self.estimate = estimate
4369 rajveer 18415 
    self.isReminder = isReminder
4303 rajveer 18416 
 
18417 
  def read(self, iprot):
18418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18420 
      return
18421 
    iprot.readStructBegin()
18422 
    while True:
18423 
      (fname, ftype, fid) = iprot.readFieldBegin()
18424 
      if ftype == TType.STOP:
18425 
        break
18426 
      if fid == 1:
18427 
        if ftype == TType.I64:
18428 
          self.vendorId = iprot.readI64();
18429 
        else:
18430 
          iprot.skip(ftype)
18431 
      elif fid == 2:
18432 
        if ftype == TType.I64:
18433 
          self.itemId = iprot.readI64();
18434 
        else:
18435 
          iprot.skip(ftype)
18436 
      elif fid == 3:
18437 
        if ftype == TType.I64:
18438 
          self.quantity = iprot.readI64();
18439 
        else:
18440 
          iprot.skip(ftype)
18441 
      elif fid == 4:
18442 
        if ftype == TType.I64:
18443 
          self.estimate = iprot.readI64();
18444 
        else:
18445 
          iprot.skip(ftype)
4369 rajveer 18446 
      elif fid == 5:
18447 
        if ftype == TType.BOOL:
18448 
          self.isReminder = iprot.readBool();
18449 
        else:
18450 
          iprot.skip(ftype)
4303 rajveer 18451 
      else:
18452 
        iprot.skip(ftype)
18453 
      iprot.readFieldEnd()
18454 
    iprot.readStructEnd()
18455 
 
18456 
  def write(self, oprot):
18457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18459 
      return
18460 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18461 
    if self.vendorId is not None:
18462 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18463 
      oprot.writeI64(self.vendorId)
18464 
      oprot.writeFieldEnd()
18465 
    if self.itemId is not None:
18466 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18467 
      oprot.writeI64(self.itemId)
18468 
      oprot.writeFieldEnd()
18469 
    if self.quantity is not None:
18470 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18471 
      oprot.writeI64(self.quantity)
18472 
      oprot.writeFieldEnd()
18473 
    if self.estimate is not None:
18474 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18475 
      oprot.writeI64(self.estimate)
18476 
      oprot.writeFieldEnd()
4369 rajveer 18477 
    if self.isReminder is not None:
18478 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18479 
      oprot.writeBool(self.isReminder)
18480 
      oprot.writeFieldEnd()
4303 rajveer 18481 
    oprot.writeFieldStop()
18482 
    oprot.writeStructEnd()
18483 
 
18484 
  def validate(self):
18485 
    return
18486 
 
18487 
 
18488 
  def __repr__(self):
18489 
    L = ['%s=%r' % (key, value)
18490 
      for key, value in self.__dict__.iteritems()]
18491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18492 
 
18493 
  def __eq__(self, other):
18494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18495 
 
18496 
  def __ne__(self, other):
18497 
    return not (self == other)
18498 
 
18499 
class markOrdersAsPORaised_result:
18500 
  """
18501 
  Attributes:
18502 
   - ex
18503 
  """
18504 
 
18505 
  thrift_spec = (
18506 
    None, # 0
18507 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18508 
  )
18509 
 
18510 
  def __init__(self, ex=None,):
18511 
    self.ex = ex
18512 
 
18513 
  def read(self, iprot):
18514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18516 
      return
18517 
    iprot.readStructBegin()
18518 
    while True:
18519 
      (fname, ftype, fid) = iprot.readFieldBegin()
18520 
      if ftype == TType.STOP:
18521 
        break
18522 
      if fid == 1:
18523 
        if ftype == TType.STRUCT:
18524 
          self.ex = TransactionServiceException()
18525 
          self.ex.read(iprot)
18526 
        else:
18527 
          iprot.skip(ftype)
18528 
      else:
18529 
        iprot.skip(ftype)
18530 
      iprot.readFieldEnd()
18531 
    iprot.readStructEnd()
18532 
 
18533 
  def write(self, oprot):
18534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18536 
      return
18537 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18538 
    if self.ex is not None:
18539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18540 
      self.ex.write(oprot)
18541 
      oprot.writeFieldEnd()
18542 
    oprot.writeFieldStop()
18543 
    oprot.writeStructEnd()
18544 
 
18545 
  def validate(self):
18546 
    return
18547 
 
18548 
 
18549 
  def __repr__(self):
18550 
    L = ['%s=%r' % (key, value)
18551 
      for key, value in self.__dict__.iteritems()]
18552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18553 
 
18554 
  def __eq__(self, other):
18555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18556 
 
18557 
  def __ne__(self, other):
18558 
    return not (self == other)
18559 
 
18560 
class markOrdersAsReversalInitiated_args:
18561 
  """
18562 
  Attributes:
18563 
   - vendorId
18564 
   - itemId
18565 
   - quantity
18566 
   - estimate
4369 rajveer 18567 
   - isReminder
4303 rajveer 18568 
  """
18569 
 
18570 
  thrift_spec = (
18571 
    None, # 0
18572 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18573 
    (2, TType.I64, 'itemId', None, None, ), # 2
18574 
    (3, TType.I64, 'quantity', None, None, ), # 3
18575 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18576 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18577 
  )
18578 
 
4369 rajveer 18579 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18580 
    self.vendorId = vendorId
18581 
    self.itemId = itemId
18582 
    self.quantity = quantity
18583 
    self.estimate = estimate
4369 rajveer 18584 
    self.isReminder = isReminder
4303 rajveer 18585 
 
18586 
  def read(self, iprot):
18587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18589 
      return
18590 
    iprot.readStructBegin()
18591 
    while True:
18592 
      (fname, ftype, fid) = iprot.readFieldBegin()
18593 
      if ftype == TType.STOP:
18594 
        break
18595 
      if fid == 1:
18596 
        if ftype == TType.I64:
18597 
          self.vendorId = iprot.readI64();
18598 
        else:
18599 
          iprot.skip(ftype)
18600 
      elif fid == 2:
18601 
        if ftype == TType.I64:
18602 
          self.itemId = iprot.readI64();
18603 
        else:
18604 
          iprot.skip(ftype)
18605 
      elif fid == 3:
18606 
        if ftype == TType.I64:
18607 
          self.quantity = iprot.readI64();
18608 
        else:
18609 
          iprot.skip(ftype)
18610 
      elif fid == 4:
18611 
        if ftype == TType.I64:
18612 
          self.estimate = iprot.readI64();
18613 
        else:
18614 
          iprot.skip(ftype)
4369 rajveer 18615 
      elif fid == 5:
18616 
        if ftype == TType.BOOL:
18617 
          self.isReminder = iprot.readBool();
18618 
        else:
18619 
          iprot.skip(ftype)
4303 rajveer 18620 
      else:
18621 
        iprot.skip(ftype)
18622 
      iprot.readFieldEnd()
18623 
    iprot.readStructEnd()
18624 
 
18625 
  def write(self, oprot):
18626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18628 
      return
18629 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18630 
    if self.vendorId is not None:
18631 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18632 
      oprot.writeI64(self.vendorId)
18633 
      oprot.writeFieldEnd()
18634 
    if self.itemId is not None:
18635 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18636 
      oprot.writeI64(self.itemId)
18637 
      oprot.writeFieldEnd()
18638 
    if self.quantity is not None:
18639 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18640 
      oprot.writeI64(self.quantity)
18641 
      oprot.writeFieldEnd()
18642 
    if self.estimate is not None:
18643 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18644 
      oprot.writeI64(self.estimate)
18645 
      oprot.writeFieldEnd()
4369 rajveer 18646 
    if self.isReminder is not None:
18647 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18648 
      oprot.writeBool(self.isReminder)
18649 
      oprot.writeFieldEnd()
4303 rajveer 18650 
    oprot.writeFieldStop()
18651 
    oprot.writeStructEnd()
18652 
 
18653 
  def validate(self):
18654 
    return
18655 
 
18656 
 
18657 
  def __repr__(self):
18658 
    L = ['%s=%r' % (key, value)
18659 
      for key, value in self.__dict__.iteritems()]
18660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18661 
 
18662 
  def __eq__(self, other):
18663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18664 
 
18665 
  def __ne__(self, other):
18666 
    return not (self == other)
18667 
 
18668 
class markOrdersAsReversalInitiated_result:
18669 
  """
18670 
  Attributes:
18671 
   - ex
18672 
  """
18673 
 
18674 
  thrift_spec = (
18675 
    None, # 0
18676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18677 
  )
18678 
 
18679 
  def __init__(self, ex=None,):
18680 
    self.ex = ex
18681 
 
18682 
  def read(self, iprot):
18683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18685 
      return
18686 
    iprot.readStructBegin()
18687 
    while True:
18688 
      (fname, ftype, fid) = iprot.readFieldBegin()
18689 
      if ftype == TType.STOP:
18690 
        break
18691 
      if fid == 1:
18692 
        if ftype == TType.STRUCT:
18693 
          self.ex = TransactionServiceException()
18694 
          self.ex.read(iprot)
18695 
        else:
18696 
          iprot.skip(ftype)
18697 
      else:
18698 
        iprot.skip(ftype)
18699 
      iprot.readFieldEnd()
18700 
    iprot.readStructEnd()
18701 
 
18702 
  def write(self, oprot):
18703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18705 
      return
18706 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18707 
    if self.ex is not None:
18708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18709 
      self.ex.write(oprot)
18710 
      oprot.writeFieldEnd()
18711 
    oprot.writeFieldStop()
18712 
    oprot.writeStructEnd()
18713 
 
18714 
  def validate(self):
18715 
    return
18716 
 
18717 
 
18718 
  def __repr__(self):
18719 
    L = ['%s=%r' % (key, value)
18720 
      for key, value in self.__dict__.iteritems()]
18721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18722 
 
18723 
  def __eq__(self, other):
18724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18725 
 
18726 
  def __ne__(self, other):
18727 
    return not (self == other)
18728 
 
18729 
class markOrdersAsNotAvailabke_args:
18730 
  """
18731 
  Attributes:
18732 
   - vendorId
18733 
   - itemId
18734 
   - quantity
18735 
   - estimate
4369 rajveer 18736 
   - isReminder
4303 rajveer 18737 
  """
18738 
 
18739 
  thrift_spec = (
18740 
    None, # 0
18741 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18742 
    (2, TType.I64, 'itemId', None, None, ), # 2
18743 
    (3, TType.I64, 'quantity', None, None, ), # 3
18744 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18745 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18746 
  )
18747 
 
4369 rajveer 18748 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18749 
    self.vendorId = vendorId
18750 
    self.itemId = itemId
18751 
    self.quantity = quantity
18752 
    self.estimate = estimate
4369 rajveer 18753 
    self.isReminder = isReminder
4303 rajveer 18754 
 
18755 
  def read(self, iprot):
18756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18758 
      return
18759 
    iprot.readStructBegin()
18760 
    while True:
18761 
      (fname, ftype, fid) = iprot.readFieldBegin()
18762 
      if ftype == TType.STOP:
18763 
        break
18764 
      if fid == 1:
18765 
        if ftype == TType.I64:
18766 
          self.vendorId = iprot.readI64();
18767 
        else:
18768 
          iprot.skip(ftype)
18769 
      elif fid == 2:
18770 
        if ftype == TType.I64:
18771 
          self.itemId = iprot.readI64();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      elif fid == 3:
18775 
        if ftype == TType.I64:
18776 
          self.quantity = iprot.readI64();
18777 
        else:
18778 
          iprot.skip(ftype)
18779 
      elif fid == 4:
18780 
        if ftype == TType.I64:
18781 
          self.estimate = iprot.readI64();
18782 
        else:
18783 
          iprot.skip(ftype)
4369 rajveer 18784 
      elif fid == 5:
18785 
        if ftype == TType.BOOL:
18786 
          self.isReminder = iprot.readBool();
18787 
        else:
18788 
          iprot.skip(ftype)
4303 rajveer 18789 
      else:
18790 
        iprot.skip(ftype)
18791 
      iprot.readFieldEnd()
18792 
    iprot.readStructEnd()
18793 
 
18794 
  def write(self, oprot):
18795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18797 
      return
18798 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18799 
    if self.vendorId is not None:
18800 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18801 
      oprot.writeI64(self.vendorId)
18802 
      oprot.writeFieldEnd()
18803 
    if self.itemId is not None:
18804 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18805 
      oprot.writeI64(self.itemId)
18806 
      oprot.writeFieldEnd()
18807 
    if self.quantity is not None:
18808 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18809 
      oprot.writeI64(self.quantity)
18810 
      oprot.writeFieldEnd()
18811 
    if self.estimate is not None:
18812 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18813 
      oprot.writeI64(self.estimate)
18814 
      oprot.writeFieldEnd()
4369 rajveer 18815 
    if self.isReminder is not None:
18816 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18817 
      oprot.writeBool(self.isReminder)
18818 
      oprot.writeFieldEnd()
4303 rajveer 18819 
    oprot.writeFieldStop()
18820 
    oprot.writeStructEnd()
18821 
 
18822 
  def validate(self):
18823 
    return
18824 
 
18825 
 
18826 
  def __repr__(self):
18827 
    L = ['%s=%r' % (key, value)
18828 
      for key, value in self.__dict__.iteritems()]
18829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18830 
 
18831 
  def __eq__(self, other):
18832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18833 
 
18834 
  def __ne__(self, other):
18835 
    return not (self == other)
18836 
 
18837 
class markOrdersAsNotAvailabke_result:
18838 
  """
18839 
  Attributes:
18840 
   - ex
18841 
  """
18842 
 
18843 
  thrift_spec = (
18844 
    None, # 0
18845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18846 
  )
18847 
 
18848 
  def __init__(self, ex=None,):
18849 
    self.ex = ex
18850 
 
18851 
  def read(self, iprot):
18852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18854 
      return
18855 
    iprot.readStructBegin()
18856 
    while True:
18857 
      (fname, ftype, fid) = iprot.readFieldBegin()
18858 
      if ftype == TType.STOP:
18859 
        break
18860 
      if fid == 1:
18861 
        if ftype == TType.STRUCT:
18862 
          self.ex = TransactionServiceException()
18863 
          self.ex.read(iprot)
18864 
        else:
18865 
          iprot.skip(ftype)
18866 
      else:
18867 
        iprot.skip(ftype)
18868 
      iprot.readFieldEnd()
18869 
    iprot.readStructEnd()
18870 
 
18871 
  def write(self, oprot):
18872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18874 
      return
18875 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
18876 
    if self.ex is not None:
18877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18878 
      self.ex.write(oprot)
18879 
      oprot.writeFieldEnd()
18880 
    oprot.writeFieldStop()
18881 
    oprot.writeStructEnd()
18882 
 
18883 
  def validate(self):
18884 
    return
18885 
 
18886 
 
18887 
  def __repr__(self):
18888 
    L = ['%s=%r' % (key, value)
18889 
      for key, value in self.__dict__.iteritems()]
18890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18891 
 
18892 
  def __eq__(self, other):
18893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18894 
 
18895 
  def __ne__(self, other):
18896 
    return not (self == other)
4369 rajveer 18897 
 
18898 
class markOrdersAsTimeout_args:
18899 
  """
18900 
  Attributes:
18901 
   - vendorId
18902 
  """
18903 
 
18904 
  thrift_spec = (
18905 
    None, # 0
18906 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18907 
  )
18908 
 
18909 
  def __init__(self, vendorId=None,):
18910 
    self.vendorId = vendorId
18911 
 
18912 
  def read(self, iprot):
18913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18915 
      return
18916 
    iprot.readStructBegin()
18917 
    while True:
18918 
      (fname, ftype, fid) = iprot.readFieldBegin()
18919 
      if ftype == TType.STOP:
18920 
        break
18921 
      if fid == 1:
18922 
        if ftype == TType.I64:
18923 
          self.vendorId = iprot.readI64();
18924 
        else:
18925 
          iprot.skip(ftype)
18926 
      else:
18927 
        iprot.skip(ftype)
18928 
      iprot.readFieldEnd()
18929 
    iprot.readStructEnd()
18930 
 
18931 
  def write(self, oprot):
18932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18934 
      return
18935 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
18936 
    if self.vendorId is not None:
18937 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18938 
      oprot.writeI64(self.vendorId)
18939 
      oprot.writeFieldEnd()
18940 
    oprot.writeFieldStop()
18941 
    oprot.writeStructEnd()
18942 
 
18943 
  def validate(self):
18944 
    return
18945 
 
18946 
 
18947 
  def __repr__(self):
18948 
    L = ['%s=%r' % (key, value)
18949 
      for key, value in self.__dict__.iteritems()]
18950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18951 
 
18952 
  def __eq__(self, other):
18953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18954 
 
18955 
  def __ne__(self, other):
18956 
    return not (self == other)
18957 
 
18958 
class markOrdersAsTimeout_result:
18959 
  """
18960 
  Attributes:
18961 
   - success
18962 
   - ex
18963 
  """
18964 
 
18965 
  thrift_spec = (
18966 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
18967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18968 
  )
18969 
 
18970 
  def __init__(self, success=None, ex=None,):
18971 
    self.success = success
18972 
    self.ex = ex
18973 
 
18974 
  def read(self, iprot):
18975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18977 
      return
18978 
    iprot.readStructBegin()
18979 
    while True:
18980 
      (fname, ftype, fid) = iprot.readFieldBegin()
18981 
      if ftype == TType.STOP:
18982 
        break
18983 
      if fid == 0:
18984 
        if ftype == TType.MAP:
18985 
          self.success = {}
4999 phani.kuma 18986 
          (_ktype403, _vtype404, _size402 ) = iprot.readMapBegin()
18987 
          for _i406 in xrange(_size402):
18988 
            _key407 = iprot.readI32();
18989 
            _val408 = TimeoutSummary()
18990 
            _val408.read(iprot)
18991 
            self.success[_key407] = _val408
4369 rajveer 18992 
          iprot.readMapEnd()
18993 
        else:
18994 
          iprot.skip(ftype)
18995 
      elif fid == 1:
18996 
        if ftype == TType.STRUCT:
18997 
          self.ex = TransactionServiceException()
18998 
          self.ex.read(iprot)
18999 
        else:
19000 
          iprot.skip(ftype)
19001 
      else:
19002 
        iprot.skip(ftype)
19003 
      iprot.readFieldEnd()
19004 
    iprot.readStructEnd()
19005 
 
19006 
  def write(self, oprot):
19007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19009 
      return
19010 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19011 
    if self.success is not None:
19012 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19013 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4999 phani.kuma 19014 
      for kiter409,viter410 in self.success.items():
19015 
        oprot.writeI32(kiter409)
19016 
        viter410.write(oprot)
4369 rajveer 19017 
      oprot.writeMapEnd()
19018 
      oprot.writeFieldEnd()
19019 
    if self.ex is not None:
19020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19021 
      self.ex.write(oprot)
19022 
      oprot.writeFieldEnd()
19023 
    oprot.writeFieldStop()
19024 
    oprot.writeStructEnd()
19025 
 
19026 
  def validate(self):
19027 
    return
19028 
 
19029 
 
19030 
  def __repr__(self):
19031 
    L = ['%s=%r' % (key, value)
19032 
      for key, value in self.__dict__.iteritems()]
19033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19034 
 
19035 
  def __eq__(self, other):
19036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19037 
 
19038 
  def __ne__(self, other):
19039 
    return not (self == other)
4386 anupam.sin 19040 
 
4662 rajveer 19041 
class markOrderAsLostInTransit_args:
19042 
  """
19043 
  Attributes:
19044 
   - orderId
19045 
  """
19046 
 
19047 
  thrift_spec = (
19048 
    None, # 0
19049 
    (1, TType.I64, 'orderId', None, None, ), # 1
19050 
  )
19051 
 
19052 
  def __init__(self, orderId=None,):
19053 
    self.orderId = orderId
19054 
 
19055 
  def read(self, iprot):
19056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19058 
      return
19059 
    iprot.readStructBegin()
19060 
    while True:
19061 
      (fname, ftype, fid) = iprot.readFieldBegin()
19062 
      if ftype == TType.STOP:
19063 
        break
19064 
      if fid == 1:
19065 
        if ftype == TType.I64:
19066 
          self.orderId = iprot.readI64();
19067 
        else:
19068 
          iprot.skip(ftype)
19069 
      else:
19070 
        iprot.skip(ftype)
19071 
      iprot.readFieldEnd()
19072 
    iprot.readStructEnd()
19073 
 
19074 
  def write(self, oprot):
19075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19077 
      return
19078 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19079 
    if self.orderId is not None:
19080 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19081 
      oprot.writeI64(self.orderId)
19082 
      oprot.writeFieldEnd()
19083 
    oprot.writeFieldStop()
19084 
    oprot.writeStructEnd()
19085 
 
19086 
  def validate(self):
19087 
    return
19088 
 
19089 
 
19090 
  def __repr__(self):
19091 
    L = ['%s=%r' % (key, value)
19092 
      for key, value in self.__dict__.iteritems()]
19093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19094 
 
19095 
  def __eq__(self, other):
19096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19097 
 
19098 
  def __ne__(self, other):
19099 
    return not (self == other)
19100 
 
19101 
class markOrderAsLostInTransit_result:
19102 
  """
19103 
  Attributes:
19104 
   - success
19105 
   - ex
19106 
  """
19107 
 
19108 
  thrift_spec = (
19109 
    (0, TType.BOOL, 'success', None, None, ), # 0
19110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19111 
  )
19112 
 
19113 
  def __init__(self, success=None, ex=None,):
19114 
    self.success = success
19115 
    self.ex = ex
19116 
 
19117 
  def read(self, iprot):
19118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19120 
      return
19121 
    iprot.readStructBegin()
19122 
    while True:
19123 
      (fname, ftype, fid) = iprot.readFieldBegin()
19124 
      if ftype == TType.STOP:
19125 
        break
19126 
      if fid == 0:
19127 
        if ftype == TType.BOOL:
19128 
          self.success = iprot.readBool();
19129 
        else:
19130 
          iprot.skip(ftype)
19131 
      elif fid == 1:
19132 
        if ftype == TType.STRUCT:
19133 
          self.ex = TransactionServiceException()
19134 
          self.ex.read(iprot)
19135 
        else:
19136 
          iprot.skip(ftype)
19137 
      else:
19138 
        iprot.skip(ftype)
19139 
      iprot.readFieldEnd()
19140 
    iprot.readStructEnd()
19141 
 
19142 
  def write(self, oprot):
19143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19145 
      return
19146 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19147 
    if self.success is not None:
19148 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19149 
      oprot.writeBool(self.success)
19150 
      oprot.writeFieldEnd()
19151 
    if self.ex is not None:
19152 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19153 
      self.ex.write(oprot)
19154 
      oprot.writeFieldEnd()
19155 
    oprot.writeFieldStop()
19156 
    oprot.writeStructEnd()
19157 
 
19158 
  def validate(self):
19159 
    return
19160 
 
19161 
 
19162 
  def __repr__(self):
19163 
    L = ['%s=%r' % (key, value)
19164 
      for key, value in self.__dict__.iteritems()]
19165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19166 
 
19167 
  def __eq__(self, other):
19168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19169 
 
19170 
  def __ne__(self, other):
19171 
    return not (self == other)
19172 
 
4386 anupam.sin 19173 
class getOrderForAwb_args:
19174 
  """
19175 
  Attributes:
19176 
   - awb
19177 
  """
19178 
 
19179 
  thrift_spec = (
19180 
    None, # 0
19181 
    (1, TType.STRING, 'awb', None, None, ), # 1
19182 
  )
19183 
 
19184 
  def __init__(self, awb=None,):
19185 
    self.awb = awb
19186 
 
19187 
  def read(self, iprot):
19188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19190 
      return
19191 
    iprot.readStructBegin()
19192 
    while True:
19193 
      (fname, ftype, fid) = iprot.readFieldBegin()
19194 
      if ftype == TType.STOP:
19195 
        break
19196 
      if fid == 1:
19197 
        if ftype == TType.STRING:
19198 
          self.awb = iprot.readString();
19199 
        else:
19200 
          iprot.skip(ftype)
19201 
      else:
19202 
        iprot.skip(ftype)
19203 
      iprot.readFieldEnd()
19204 
    iprot.readStructEnd()
19205 
 
19206 
  def write(self, oprot):
19207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19209 
      return
19210 
    oprot.writeStructBegin('getOrderForAwb_args')
19211 
    if self.awb is not None:
19212 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19213 
      oprot.writeString(self.awb)
19214 
      oprot.writeFieldEnd()
19215 
    oprot.writeFieldStop()
19216 
    oprot.writeStructEnd()
19217 
 
19218 
  def validate(self):
19219 
    return
19220 
 
19221 
 
19222 
  def __repr__(self):
19223 
    L = ['%s=%r' % (key, value)
19224 
      for key, value in self.__dict__.iteritems()]
19225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19226 
 
19227 
  def __eq__(self, other):
19228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19229 
 
19230 
  def __ne__(self, other):
19231 
    return not (self == other)
19232 
 
19233 
class getOrderForAwb_result:
19234 
  """
19235 
  Attributes:
19236 
   - success
19237 
   - ex
19238 
  """
19239 
 
19240 
  thrift_spec = (
19241 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19242 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19243 
  )
19244 
 
19245 
  def __init__(self, success=None, ex=None,):
19246 
    self.success = success
19247 
    self.ex = ex
19248 
 
19249 
  def read(self, iprot):
19250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19252 
      return
19253 
    iprot.readStructBegin()
19254 
    while True:
19255 
      (fname, ftype, fid) = iprot.readFieldBegin()
19256 
      if ftype == TType.STOP:
19257 
        break
19258 
      if fid == 0:
19259 
        if ftype == TType.STRUCT:
19260 
          self.success = Order()
19261 
          self.success.read(iprot)
19262 
        else:
19263 
          iprot.skip(ftype)
19264 
      elif fid == 1:
19265 
        if ftype == TType.STRUCT:
19266 
          self.ex = TransactionServiceException()
19267 
          self.ex.read(iprot)
19268 
        else:
19269 
          iprot.skip(ftype)
19270 
      else:
19271 
        iprot.skip(ftype)
19272 
      iprot.readFieldEnd()
19273 
    iprot.readStructEnd()
19274 
 
19275 
  def write(self, oprot):
19276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19278 
      return
19279 
    oprot.writeStructBegin('getOrderForAwb_result')
19280 
    if self.success is not None:
19281 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19282 
      self.success.write(oprot)
19283 
      oprot.writeFieldEnd()
19284 
    if self.ex is not None:
19285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19286 
      self.ex.write(oprot)
19287 
      oprot.writeFieldEnd()
19288 
    oprot.writeFieldStop()
19289 
    oprot.writeStructEnd()
19290 
 
19291 
  def validate(self):
19292 
    return
19293 
 
19294 
 
19295 
  def __repr__(self):
19296 
    L = ['%s=%r' % (key, value)
19297 
      for key, value in self.__dict__.iteritems()]
19298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19299 
 
19300 
  def __eq__(self, other):
19301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19302 
 
19303 
  def __ne__(self, other):
19304 
    return not (self == other)
4506 phani.kuma 19305 
 
19306 
class getOrdersForProviderForStatus_args:
19307 
  """
19308 
  Attributes:
19309 
   - logistics_provider_id
4910 phani.kuma 19310 
   - order_status_list
4506 phani.kuma 19311 
  """
19312 
 
19313 
  thrift_spec = (
19314 
    None, # 0
19315 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19316 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19317 
  )
19318 
 
4910 phani.kuma 19319 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19320 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19321 
    self.order_status_list = order_status_list
4506 phani.kuma 19322 
 
19323 
  def read(self, iprot):
19324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19326 
      return
19327 
    iprot.readStructBegin()
19328 
    while True:
19329 
      (fname, ftype, fid) = iprot.readFieldBegin()
19330 
      if ftype == TType.STOP:
19331 
        break
19332 
      if fid == 1:
19333 
        if ftype == TType.I64:
19334 
          self.logistics_provider_id = iprot.readI64();
19335 
        else:
19336 
          iprot.skip(ftype)
19337 
      elif fid == 2:
4910 phani.kuma 19338 
        if ftype == TType.LIST:
19339 
          self.order_status_list = []
4999 phani.kuma 19340 
          (_etype414, _size411) = iprot.readListBegin()
19341 
          for _i415 in xrange(_size411):
19342 
            _elem416 = iprot.readI32();
19343 
            self.order_status_list.append(_elem416)
4910 phani.kuma 19344 
          iprot.readListEnd()
4506 phani.kuma 19345 
        else:
19346 
          iprot.skip(ftype)
19347 
      else:
19348 
        iprot.skip(ftype)
19349 
      iprot.readFieldEnd()
19350 
    iprot.readStructEnd()
19351 
 
19352 
  def write(self, oprot):
19353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19355 
      return
19356 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19357 
    if self.logistics_provider_id is not None:
19358 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19359 
      oprot.writeI64(self.logistics_provider_id)
19360 
      oprot.writeFieldEnd()
4910 phani.kuma 19361 
    if self.order_status_list is not None:
19362 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19363 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
4999 phani.kuma 19364 
      for iter417 in self.order_status_list:
19365 
        oprot.writeI32(iter417)
4910 phani.kuma 19366 
      oprot.writeListEnd()
4506 phani.kuma 19367 
      oprot.writeFieldEnd()
19368 
    oprot.writeFieldStop()
19369 
    oprot.writeStructEnd()
19370 
 
19371 
  def validate(self):
19372 
    return
19373 
 
19374 
 
19375 
  def __repr__(self):
19376 
    L = ['%s=%r' % (key, value)
19377 
      for key, value in self.__dict__.iteritems()]
19378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19379 
 
19380 
  def __eq__(self, other):
19381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19382 
 
19383 
  def __ne__(self, other):
19384 
    return not (self == other)
19385 
 
19386 
class getOrdersForProviderForStatus_result:
19387 
  """
19388 
  Attributes:
19389 
   - success
19390 
   - ex
19391 
  """
19392 
 
19393 
  thrift_spec = (
19394 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19396 
  )
19397 
 
19398 
  def __init__(self, success=None, ex=None,):
19399 
    self.success = success
19400 
    self.ex = ex
19401 
 
19402 
  def read(self, iprot):
19403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19405 
      return
19406 
    iprot.readStructBegin()
19407 
    while True:
19408 
      (fname, ftype, fid) = iprot.readFieldBegin()
19409 
      if ftype == TType.STOP:
19410 
        break
19411 
      if fid == 0:
19412 
        if ftype == TType.LIST:
19413 
          self.success = []
4999 phani.kuma 19414 
          (_etype421, _size418) = iprot.readListBegin()
19415 
          for _i422 in xrange(_size418):
19416 
            _elem423 = Order()
19417 
            _elem423.read(iprot)
19418 
            self.success.append(_elem423)
4506 phani.kuma 19419 
          iprot.readListEnd()
19420 
        else:
19421 
          iprot.skip(ftype)
19422 
      elif fid == 1:
19423 
        if ftype == TType.STRUCT:
19424 
          self.ex = TransactionServiceException()
19425 
          self.ex.read(iprot)
19426 
        else:
19427 
          iprot.skip(ftype)
19428 
      else:
19429 
        iprot.skip(ftype)
19430 
      iprot.readFieldEnd()
19431 
    iprot.readStructEnd()
19432 
 
19433 
  def write(self, oprot):
19434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19436 
      return
19437 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19438 
    if self.success is not None:
19439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 19441 
      for iter424 in self.success:
19442 
        iter424.write(oprot)
4506 phani.kuma 19443 
      oprot.writeListEnd()
19444 
      oprot.writeFieldEnd()
19445 
    if self.ex is not None:
19446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19447 
      self.ex.write(oprot)
19448 
      oprot.writeFieldEnd()
19449 
    oprot.writeFieldStop()
19450 
    oprot.writeStructEnd()
19451 
 
19452 
  def validate(self):
19453 
    return
19454 
 
19455 
 
19456 
  def __repr__(self):
19457 
    L = ['%s=%r' % (key, value)
19458 
      for key, value in self.__dict__.iteritems()]
19459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19460 
 
19461 
  def __eq__(self, other):
19462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19463 
 
19464 
  def __ne__(self, other):
19465 
    return not (self == other)
4600 varun.gupt 19466 
 
19467 
class getBilledOrdersForVendor_args:
19468 
  """
19469 
  Attributes:
19470 
   - vendorId
19471 
   - billingDateFrom
19472 
   - billingDateTo
19473 
  """
19474 
 
19475 
  thrift_spec = (
19476 
    None, # 0
19477 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19478 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19479 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19480 
  )
19481 
 
19482 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19483 
    self.vendorId = vendorId
19484 
    self.billingDateFrom = billingDateFrom
19485 
    self.billingDateTo = billingDateTo
19486 
 
19487 
  def read(self, iprot):
19488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19490 
      return
19491 
    iprot.readStructBegin()
19492 
    while True:
19493 
      (fname, ftype, fid) = iprot.readFieldBegin()
19494 
      if ftype == TType.STOP:
19495 
        break
19496 
      if fid == 1:
19497 
        if ftype == TType.I64:
19498 
          self.vendorId = iprot.readI64();
19499 
        else:
19500 
          iprot.skip(ftype)
19501 
      elif fid == 2:
19502 
        if ftype == TType.I64:
19503 
          self.billingDateFrom = iprot.readI64();
19504 
        else:
19505 
          iprot.skip(ftype)
19506 
      elif fid == 3:
19507 
        if ftype == TType.I64:
19508 
          self.billingDateTo = iprot.readI64();
19509 
        else:
19510 
          iprot.skip(ftype)
19511 
      else:
19512 
        iprot.skip(ftype)
19513 
      iprot.readFieldEnd()
19514 
    iprot.readStructEnd()
19515 
 
19516 
  def write(self, oprot):
19517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19519 
      return
19520 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19521 
    if self.vendorId is not None:
19522 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19523 
      oprot.writeI64(self.vendorId)
19524 
      oprot.writeFieldEnd()
19525 
    if self.billingDateFrom is not None:
19526 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19527 
      oprot.writeI64(self.billingDateFrom)
19528 
      oprot.writeFieldEnd()
19529 
    if self.billingDateTo is not None:
19530 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19531 
      oprot.writeI64(self.billingDateTo)
19532 
      oprot.writeFieldEnd()
19533 
    oprot.writeFieldStop()
19534 
    oprot.writeStructEnd()
19535 
 
19536 
  def validate(self):
19537 
    return
19538 
 
19539 
 
19540 
  def __repr__(self):
19541 
    L = ['%s=%r' % (key, value)
19542 
      for key, value in self.__dict__.iteritems()]
19543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19544 
 
19545 
  def __eq__(self, other):
19546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19547 
 
19548 
  def __ne__(self, other):
19549 
    return not (self == other)
19550 
 
19551 
class getBilledOrdersForVendor_result:
19552 
  """
19553 
  Attributes:
19554 
   - success
19555 
   - ex
19556 
  """
19557 
 
19558 
  thrift_spec = (
19559 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19561 
  )
19562 
 
19563 
  def __init__(self, success=None, ex=None,):
19564 
    self.success = success
19565 
    self.ex = ex
19566 
 
19567 
  def read(self, iprot):
19568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19570 
      return
19571 
    iprot.readStructBegin()
19572 
    while True:
19573 
      (fname, ftype, fid) = iprot.readFieldBegin()
19574 
      if ftype == TType.STOP:
19575 
        break
19576 
      if fid == 0:
19577 
        if ftype == TType.LIST:
19578 
          self.success = []
4999 phani.kuma 19579 
          (_etype428, _size425) = iprot.readListBegin()
19580 
          for _i429 in xrange(_size425):
19581 
            _elem430 = Order()
19582 
            _elem430.read(iprot)
19583 
            self.success.append(_elem430)
4600 varun.gupt 19584 
          iprot.readListEnd()
19585 
        else:
19586 
          iprot.skip(ftype)
19587 
      elif fid == 1:
19588 
        if ftype == TType.STRUCT:
19589 
          self.ex = TransactionServiceException()
19590 
          self.ex.read(iprot)
19591 
        else:
19592 
          iprot.skip(ftype)
19593 
      else:
19594 
        iprot.skip(ftype)
19595 
      iprot.readFieldEnd()
19596 
    iprot.readStructEnd()
19597 
 
19598 
  def write(self, oprot):
19599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19601 
      return
19602 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19603 
    if self.success is not None:
19604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 19606 
      for iter431 in self.success:
19607 
        iter431.write(oprot)
4600 varun.gupt 19608 
      oprot.writeListEnd()
19609 
      oprot.writeFieldEnd()
19610 
    if self.ex is not None:
19611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19612 
      self.ex.write(oprot)
19613 
      oprot.writeFieldEnd()
19614 
    oprot.writeFieldStop()
19615 
    oprot.writeStructEnd()
19616 
 
19617 
  def validate(self):
19618 
    return
19619 
 
19620 
 
19621 
  def __repr__(self):
19622 
    L = ['%s=%r' % (key, value)
19623 
      for key, value in self.__dict__.iteritems()]
19624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19625 
 
19626 
  def __eq__(self, other):
19627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19628 
 
19629 
  def __ne__(self, other):
19630 
    return not (self == other)
19631 
 
4607 rajveer 19632 
class getSlippedSippingDateOrders_args:
19633 
 
19634 
  thrift_spec = (
19635 
  )
19636 
 
19637 
  def read(self, iprot):
19638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19640 
      return
19641 
    iprot.readStructBegin()
19642 
    while True:
19643 
      (fname, ftype, fid) = iprot.readFieldBegin()
19644 
      if ftype == TType.STOP:
19645 
        break
19646 
      else:
19647 
        iprot.skip(ftype)
19648 
      iprot.readFieldEnd()
19649 
    iprot.readStructEnd()
19650 
 
19651 
  def write(self, oprot):
19652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19654 
      return
19655 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19656 
    oprot.writeFieldStop()
19657 
    oprot.writeStructEnd()
19658 
 
19659 
  def validate(self):
19660 
    return
19661 
 
19662 
 
19663 
  def __repr__(self):
19664 
    L = ['%s=%r' % (key, value)
19665 
      for key, value in self.__dict__.iteritems()]
19666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19667 
 
19668 
  def __eq__(self, other):
19669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19670 
 
19671 
  def __ne__(self, other):
19672 
    return not (self == other)
19673 
 
19674 
class getSlippedSippingDateOrders_result:
19675 
  """
19676 
  Attributes:
19677 
   - success
19678 
   - ex
19679 
  """
19680 
 
19681 
  thrift_spec = (
19682 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19684 
  )
19685 
 
19686 
  def __init__(self, success=None, ex=None,):
19687 
    self.success = success
19688 
    self.ex = ex
19689 
 
19690 
  def read(self, iprot):
19691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19693 
      return
19694 
    iprot.readStructBegin()
19695 
    while True:
19696 
      (fname, ftype, fid) = iprot.readFieldBegin()
19697 
      if ftype == TType.STOP:
19698 
        break
19699 
      if fid == 0:
19700 
        if ftype == TType.LIST:
19701 
          self.success = []
4999 phani.kuma 19702 
          (_etype435, _size432) = iprot.readListBegin()
19703 
          for _i436 in xrange(_size432):
19704 
            _elem437 = Order()
19705 
            _elem437.read(iprot)
19706 
            self.success.append(_elem437)
4607 rajveer 19707 
          iprot.readListEnd()
19708 
        else:
19709 
          iprot.skip(ftype)
19710 
      elif fid == 1:
19711 
        if ftype == TType.STRUCT:
19712 
          self.ex = TransactionServiceException()
19713 
          self.ex.read(iprot)
19714 
        else:
19715 
          iprot.skip(ftype)
19716 
      else:
19717 
        iprot.skip(ftype)
19718 
      iprot.readFieldEnd()
19719 
    iprot.readStructEnd()
19720 
 
19721 
  def write(self, oprot):
19722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19724 
      return
19725 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19726 
    if self.success is not None:
19727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 19729 
      for iter438 in self.success:
19730 
        iter438.write(oprot)
4607 rajveer 19731 
      oprot.writeListEnd()
19732 
      oprot.writeFieldEnd()
19733 
    if self.ex is not None:
19734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19735 
      self.ex.write(oprot)
19736 
      oprot.writeFieldEnd()
19737 
    oprot.writeFieldStop()
19738 
    oprot.writeStructEnd()
19739 
 
19740 
  def validate(self):
19741 
    return
19742 
 
19743 
 
19744 
  def __repr__(self):
19745 
    L = ['%s=%r' % (key, value)
19746 
      for key, value in self.__dict__.iteritems()]
19747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19748 
 
19749 
  def __eq__(self, other):
19750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19751 
 
19752 
  def __ne__(self, other):
19753 
    return not (self == other)
19754 
 
4709 rajveer 19755 
class getCancelledOrders_args:
19756 
  """
19757 
  Attributes:
19758 
   - cancelDateFrom
19759 
   - cancelDateTo
19760 
  """
19761 
 
19762 
  thrift_spec = (
19763 
    None, # 0
19764 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19765 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19766 
  )
19767 
 
19768 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19769 
    self.cancelDateFrom = cancelDateFrom
19770 
    self.cancelDateTo = cancelDateTo
19771 
 
19772 
  def read(self, iprot):
19773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19775 
      return
19776 
    iprot.readStructBegin()
19777 
    while True:
19778 
      (fname, ftype, fid) = iprot.readFieldBegin()
19779 
      if ftype == TType.STOP:
19780 
        break
19781 
      if fid == 1:
19782 
        if ftype == TType.I64:
19783 
          self.cancelDateFrom = iprot.readI64();
19784 
        else:
19785 
          iprot.skip(ftype)
19786 
      elif fid == 2:
19787 
        if ftype == TType.I64:
19788 
          self.cancelDateTo = iprot.readI64();
19789 
        else:
19790 
          iprot.skip(ftype)
19791 
      else:
19792 
        iprot.skip(ftype)
19793 
      iprot.readFieldEnd()
19794 
    iprot.readStructEnd()
19795 
 
19796 
  def write(self, oprot):
19797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19799 
      return
19800 
    oprot.writeStructBegin('getCancelledOrders_args')
19801 
    if self.cancelDateFrom is not None:
19802 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19803 
      oprot.writeI64(self.cancelDateFrom)
19804 
      oprot.writeFieldEnd()
19805 
    if self.cancelDateTo is not None:
19806 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19807 
      oprot.writeI64(self.cancelDateTo)
19808 
      oprot.writeFieldEnd()
19809 
    oprot.writeFieldStop()
19810 
    oprot.writeStructEnd()
19811 
 
19812 
  def validate(self):
19813 
    return
19814 
 
19815 
 
19816 
  def __repr__(self):
19817 
    L = ['%s=%r' % (key, value)
19818 
      for key, value in self.__dict__.iteritems()]
19819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19820 
 
19821 
  def __eq__(self, other):
19822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19823 
 
19824 
  def __ne__(self, other):
19825 
    return not (self == other)
19826 
 
19827 
class getCancelledOrders_result:
19828 
  """
19829 
  Attributes:
19830 
   - success
19831 
   - ex
19832 
  """
19833 
 
19834 
  thrift_spec = (
19835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19837 
  )
19838 
 
19839 
  def __init__(self, success=None, ex=None,):
19840 
    self.success = success
19841 
    self.ex = ex
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 0:
19853 
        if ftype == TType.LIST:
19854 
          self.success = []
4999 phani.kuma 19855 
          (_etype442, _size439) = iprot.readListBegin()
19856 
          for _i443 in xrange(_size439):
19857 
            _elem444 = Order()
19858 
            _elem444.read(iprot)
19859 
            self.success.append(_elem444)
4709 rajveer 19860 
          iprot.readListEnd()
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      elif fid == 1:
19864 
        if ftype == TType.STRUCT:
19865 
          self.ex = TransactionServiceException()
19866 
          self.ex.read(iprot)
19867 
        else:
19868 
          iprot.skip(ftype)
19869 
      else:
19870 
        iprot.skip(ftype)
19871 
      iprot.readFieldEnd()
19872 
    iprot.readStructEnd()
19873 
 
19874 
  def write(self, oprot):
19875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19877 
      return
19878 
    oprot.writeStructBegin('getCancelledOrders_result')
19879 
    if self.success is not None:
19880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 19882 
      for iter445 in self.success:
19883 
        iter445.write(oprot)
4709 rajveer 19884 
      oprot.writeListEnd()
19885 
      oprot.writeFieldEnd()
19886 
    if self.ex is not None:
19887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19888 
      self.ex.write(oprot)
19889 
      oprot.writeFieldEnd()
19890 
    oprot.writeFieldStop()
19891 
    oprot.writeStructEnd()
19892 
 
19893 
  def validate(self):
19894 
    return
19895 
 
19896 
 
19897 
  def __repr__(self):
19898 
    L = ['%s=%r' % (key, value)
19899 
      for key, value in self.__dict__.iteritems()]
19900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19901 
 
19902 
  def __eq__(self, other):
19903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19904 
 
19905 
  def __ne__(self, other):
19906 
    return not (self == other)
19907 
 
4600 varun.gupt 19908 
class saveBluedartSettlements_args:
19909 
  """
19910 
  Attributes:
19911 
   - mapAWBAndAmount
19912 
  """
19913 
 
19914 
  thrift_spec = (
19915 
    None, # 0
19916 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
19917 
  )
19918 
 
19919 
  def __init__(self, mapAWBAndAmount=None,):
19920 
    self.mapAWBAndAmount = mapAWBAndAmount
19921 
 
19922 
  def read(self, iprot):
19923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19925 
      return
19926 
    iprot.readStructBegin()
19927 
    while True:
19928 
      (fname, ftype, fid) = iprot.readFieldBegin()
19929 
      if ftype == TType.STOP:
19930 
        break
19931 
      if fid == 1:
19932 
        if ftype == TType.MAP:
19933 
          self.mapAWBAndAmount = {}
4999 phani.kuma 19934 
          (_ktype447, _vtype448, _size446 ) = iprot.readMapBegin()
19935 
          for _i450 in xrange(_size446):
19936 
            _key451 = iprot.readI64();
19937 
            _val452 = iprot.readDouble();
19938 
            self.mapAWBAndAmount[_key451] = _val452
4600 varun.gupt 19939 
          iprot.readMapEnd()
19940 
        else:
19941 
          iprot.skip(ftype)
19942 
      else:
19943 
        iprot.skip(ftype)
19944 
      iprot.readFieldEnd()
19945 
    iprot.readStructEnd()
19946 
 
19947 
  def write(self, oprot):
19948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19950 
      return
19951 
    oprot.writeStructBegin('saveBluedartSettlements_args')
19952 
    if self.mapAWBAndAmount is not None:
19953 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
19954 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4999 phani.kuma 19955 
      for kiter453,viter454 in self.mapAWBAndAmount.items():
19956 
        oprot.writeI64(kiter453)
19957 
        oprot.writeDouble(viter454)
4600 varun.gupt 19958 
      oprot.writeMapEnd()
19959 
      oprot.writeFieldEnd()
19960 
    oprot.writeFieldStop()
19961 
    oprot.writeStructEnd()
19962 
 
19963 
  def validate(self):
19964 
    return
19965 
 
19966 
 
19967 
  def __repr__(self):
19968 
    L = ['%s=%r' % (key, value)
19969 
      for key, value in self.__dict__.iteritems()]
19970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19971 
 
19972 
  def __eq__(self, other):
19973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19974 
 
19975 
  def __ne__(self, other):
19976 
    return not (self == other)
19977 
 
19978 
class saveBluedartSettlements_result:
19979 
  """
19980 
  Attributes:
19981 
   - ex
19982 
  """
19983 
 
19984 
  thrift_spec = (
19985 
    None, # 0
19986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19987 
  )
19988 
 
19989 
  def __init__(self, ex=None,):
19990 
    self.ex = ex
19991 
 
19992 
  def read(self, iprot):
19993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19995 
      return
19996 
    iprot.readStructBegin()
19997 
    while True:
19998 
      (fname, ftype, fid) = iprot.readFieldBegin()
19999 
      if ftype == TType.STOP:
20000 
        break
20001 
      if fid == 1:
20002 
        if ftype == TType.STRUCT:
20003 
          self.ex = TransactionServiceException()
20004 
          self.ex.read(iprot)
20005 
        else:
20006 
          iprot.skip(ftype)
20007 
      else:
20008 
        iprot.skip(ftype)
20009 
      iprot.readFieldEnd()
20010 
    iprot.readStructEnd()
20011 
 
20012 
  def write(self, oprot):
20013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20015 
      return
20016 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20017 
    if self.ex is not None:
20018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20019 
      self.ex.write(oprot)
20020 
      oprot.writeFieldEnd()
20021 
    oprot.writeFieldStop()
20022 
    oprot.writeStructEnd()
20023 
 
20024 
  def validate(self):
20025 
    return
20026 
 
20027 
 
20028 
  def __repr__(self):
20029 
    L = ['%s=%r' % (key, value)
20030 
      for key, value in self.__dict__.iteritems()]
20031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20032 
 
20033 
  def __eq__(self, other):
20034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20035 
 
20036 
  def __ne__(self, other):
20037 
    return not (self == other)
20038 
 
20039 
class savePaymentSettlements_args:
20040 
  """
20041 
  Attributes:
20042 
   - settlementDate
20043 
   - paymentGatewayId
4905 varun.gupt 20044 
   - referenceId
4600 varun.gupt 20045 
   - serviceTax
20046 
   - otherCharges
20047 
   - netCollection
20048 
  """
20049 
 
20050 
  thrift_spec = (
20051 
    None, # 0
20052 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20053 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20054 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20055 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20056 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20057 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20058 
  )
20059 
 
4905 varun.gupt 20060 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20061 
    self.settlementDate = settlementDate
20062 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20063 
    self.referenceId = referenceId
4600 varun.gupt 20064 
    self.serviceTax = serviceTax
20065 
    self.otherCharges = otherCharges
20066 
    self.netCollection = netCollection
20067 
 
20068 
  def read(self, iprot):
20069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20071 
      return
20072 
    iprot.readStructBegin()
20073 
    while True:
20074 
      (fname, ftype, fid) = iprot.readFieldBegin()
20075 
      if ftype == TType.STOP:
20076 
        break
20077 
      if fid == 1:
20078 
        if ftype == TType.I64:
20079 
          self.settlementDate = iprot.readI64();
20080 
        else:
20081 
          iprot.skip(ftype)
20082 
      elif fid == 2:
20083 
        if ftype == TType.I64:
20084 
          self.paymentGatewayId = iprot.readI64();
20085 
        else:
20086 
          iprot.skip(ftype)
20087 
      elif fid == 3:
20088 
        if ftype == TType.I64:
4905 varun.gupt 20089 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20090 
        else:
20091 
          iprot.skip(ftype)
20092 
      elif fid == 4:
20093 
        if ftype == TType.DOUBLE:
20094 
          self.serviceTax = iprot.readDouble();
20095 
        else:
20096 
          iprot.skip(ftype)
20097 
      elif fid == 5:
20098 
        if ftype == TType.DOUBLE:
20099 
          self.otherCharges = iprot.readDouble();
20100 
        else:
20101 
          iprot.skip(ftype)
20102 
      elif fid == 6:
20103 
        if ftype == TType.DOUBLE:
20104 
          self.netCollection = iprot.readDouble();
20105 
        else:
20106 
          iprot.skip(ftype)
20107 
      else:
20108 
        iprot.skip(ftype)
20109 
      iprot.readFieldEnd()
20110 
    iprot.readStructEnd()
20111 
 
20112 
  def write(self, oprot):
20113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20115 
      return
20116 
    oprot.writeStructBegin('savePaymentSettlements_args')
20117 
    if self.settlementDate is not None:
20118 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20119 
      oprot.writeI64(self.settlementDate)
20120 
      oprot.writeFieldEnd()
20121 
    if self.paymentGatewayId is not None:
20122 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20123 
      oprot.writeI64(self.paymentGatewayId)
20124 
      oprot.writeFieldEnd()
4905 varun.gupt 20125 
    if self.referenceId is not None:
20126 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20127 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20128 
      oprot.writeFieldEnd()
20129 
    if self.serviceTax is not None:
20130 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20131 
      oprot.writeDouble(self.serviceTax)
20132 
      oprot.writeFieldEnd()
20133 
    if self.otherCharges is not None:
20134 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20135 
      oprot.writeDouble(self.otherCharges)
20136 
      oprot.writeFieldEnd()
20137 
    if self.netCollection is not None:
20138 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20139 
      oprot.writeDouble(self.netCollection)
20140 
      oprot.writeFieldEnd()
20141 
    oprot.writeFieldStop()
20142 
    oprot.writeStructEnd()
20143 
 
20144 
  def validate(self):
20145 
    return
20146 
 
20147 
 
20148 
  def __repr__(self):
20149 
    L = ['%s=%r' % (key, value)
20150 
      for key, value in self.__dict__.iteritems()]
20151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20152 
 
20153 
  def __eq__(self, other):
20154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20155 
 
20156 
  def __ne__(self, other):
20157 
    return not (self == other)
20158 
 
20159 
class savePaymentSettlements_result:
20160 
  """
20161 
  Attributes:
20162 
   - ex
20163 
  """
20164 
 
20165 
  thrift_spec = (
20166 
    None, # 0
20167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20168 
  )
20169 
 
20170 
  def __init__(self, ex=None,):
20171 
    self.ex = ex
20172 
 
20173 
  def read(self, iprot):
20174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20176 
      return
20177 
    iprot.readStructBegin()
20178 
    while True:
20179 
      (fname, ftype, fid) = iprot.readFieldBegin()
20180 
      if ftype == TType.STOP:
20181 
        break
20182 
      if fid == 1:
20183 
        if ftype == TType.STRUCT:
20184 
          self.ex = TransactionServiceException()
20185 
          self.ex.read(iprot)
20186 
        else:
20187 
          iprot.skip(ftype)
20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('savePaymentSettlements_result')
20198 
    if self.ex is not None:
20199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20200 
      self.ex.write(oprot)
20201 
      oprot.writeFieldEnd()
20202 
    oprot.writeFieldStop()
20203 
    oprot.writeStructEnd()
20204 
 
20205 
  def validate(self):
20206 
    return
20207 
 
20208 
 
20209 
  def __repr__(self):
20210 
    L = ['%s=%r' % (key, value)
20211 
      for key, value in self.__dict__.iteritems()]
20212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20213 
 
20214 
  def __eq__(self, other):
20215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20216 
 
20217 
  def __ne__(self, other):
20218 
    return not (self == other)
20219 
 
20220 
class saveEBSSettlementSummary_args:
20221 
  """
20222 
  Attributes:
20223 
   - settlementId
20224 
   - settlementDate
20225 
   - transactionDateFrom
20226 
   - transactionDateTo
20227 
   - amount
20228 
  """
20229 
 
20230 
  thrift_spec = (
20231 
    None, # 0
20232 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20233 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20234 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20235 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20236 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20237 
  )
20238 
 
20239 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20240 
    self.settlementId = settlementId
20241 
    self.settlementDate = settlementDate
20242 
    self.transactionDateFrom = transactionDateFrom
20243 
    self.transactionDateTo = transactionDateTo
20244 
    self.amount = amount
20245 
 
20246 
  def read(self, iprot):
20247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20249 
      return
20250 
    iprot.readStructBegin()
20251 
    while True:
20252 
      (fname, ftype, fid) = iprot.readFieldBegin()
20253 
      if ftype == TType.STOP:
20254 
        break
20255 
      if fid == 1:
20256 
        if ftype == TType.I64:
20257 
          self.settlementId = iprot.readI64();
20258 
        else:
20259 
          iprot.skip(ftype)
20260 
      elif fid == 2:
20261 
        if ftype == TType.I64:
20262 
          self.settlementDate = iprot.readI64();
20263 
        else:
20264 
          iprot.skip(ftype)
20265 
      elif fid == 3:
20266 
        if ftype == TType.I64:
20267 
          self.transactionDateFrom = iprot.readI64();
20268 
        else:
20269 
          iprot.skip(ftype)
20270 
      elif fid == 4:
20271 
        if ftype == TType.I64:
20272 
          self.transactionDateTo = iprot.readI64();
20273 
        else:
20274 
          iprot.skip(ftype)
20275 
      elif fid == 5:
20276 
        if ftype == TType.DOUBLE:
20277 
          self.amount = iprot.readDouble();
20278 
        else:
20279 
          iprot.skip(ftype)
20280 
      else:
20281 
        iprot.skip(ftype)
20282 
      iprot.readFieldEnd()
20283 
    iprot.readStructEnd()
20284 
 
20285 
  def write(self, oprot):
20286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20288 
      return
20289 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20290 
    if self.settlementId is not None:
20291 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20292 
      oprot.writeI64(self.settlementId)
20293 
      oprot.writeFieldEnd()
20294 
    if self.settlementDate is not None:
20295 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20296 
      oprot.writeI64(self.settlementDate)
20297 
      oprot.writeFieldEnd()
20298 
    if self.transactionDateFrom is not None:
20299 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20300 
      oprot.writeI64(self.transactionDateFrom)
20301 
      oprot.writeFieldEnd()
20302 
    if self.transactionDateTo is not None:
20303 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20304 
      oprot.writeI64(self.transactionDateTo)
20305 
      oprot.writeFieldEnd()
20306 
    if self.amount is not None:
20307 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20308 
      oprot.writeDouble(self.amount)
20309 
      oprot.writeFieldEnd()
20310 
    oprot.writeFieldStop()
20311 
    oprot.writeStructEnd()
20312 
 
20313 
  def validate(self):
20314 
    return
20315 
 
20316 
 
20317 
  def __repr__(self):
20318 
    L = ['%s=%r' % (key, value)
20319 
      for key, value in self.__dict__.iteritems()]
20320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20321 
 
20322 
  def __eq__(self, other):
20323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20324 
 
20325 
  def __ne__(self, other):
20326 
    return not (self == other)
20327 
 
20328 
class saveEBSSettlementSummary_result:
20329 
  """
20330 
  Attributes:
20331 
   - ex
20332 
  """
20333 
 
20334 
  thrift_spec = (
20335 
    None, # 0
20336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20337 
  )
20338 
 
20339 
  def __init__(self, ex=None,):
20340 
    self.ex = ex
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 
      if fid == 1:
20352 
        if ftype == TType.STRUCT:
20353 
          self.ex = TransactionServiceException()
20354 
          self.ex.read(iprot)
20355 
        else:
20356 
          iprot.skip(ftype)
20357 
      else:
20358 
        iprot.skip(ftype)
20359 
      iprot.readFieldEnd()
20360 
    iprot.readStructEnd()
20361 
 
20362 
  def write(self, oprot):
20363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20365 
      return
20366 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20367 
    if self.ex is not None:
20368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20369 
      self.ex.write(oprot)
20370 
      oprot.writeFieldEnd()
20371 
    oprot.writeFieldStop()
20372 
    oprot.writeStructEnd()
20373 
 
20374 
  def validate(self):
20375 
    return
20376 
 
20377 
 
20378 
  def __repr__(self):
20379 
    L = ['%s=%r' % (key, value)
20380 
      for key, value in self.__dict__.iteritems()]
20381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20382 
 
20383 
  def __eq__(self, other):
20384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20385 
 
20386 
  def __ne__(self, other):
20387 
    return not (self == other)
20388 
 
20389 
class getSettlementForPaymentId_args:
20390 
  """
20391 
  Attributes:
20392 
   - paymentId
20393 
  """
20394 
 
20395 
  thrift_spec = (
20396 
    None, # 0
20397 
    (1, TType.I64, 'paymentId', None, None, ), # 1
20398 
  )
20399 
 
20400 
  def __init__(self, paymentId=None,):
20401 
    self.paymentId = paymentId
20402 
 
20403 
  def read(self, iprot):
20404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20406 
      return
20407 
    iprot.readStructBegin()
20408 
    while True:
20409 
      (fname, ftype, fid) = iprot.readFieldBegin()
20410 
      if ftype == TType.STOP:
20411 
        break
20412 
      if fid == 1:
20413 
        if ftype == TType.I64:
20414 
          self.paymentId = iprot.readI64();
20415 
        else:
20416 
          iprot.skip(ftype)
20417 
      else:
20418 
        iprot.skip(ftype)
20419 
      iprot.readFieldEnd()
20420 
    iprot.readStructEnd()
20421 
 
20422 
  def write(self, oprot):
20423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20425 
      return
20426 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
20427 
    if self.paymentId is not None:
20428 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
20429 
      oprot.writeI64(self.paymentId)
20430 
      oprot.writeFieldEnd()
20431 
    oprot.writeFieldStop()
20432 
    oprot.writeStructEnd()
20433 
 
20434 
  def validate(self):
20435 
    return
20436 
 
20437 
 
20438 
  def __repr__(self):
20439 
    L = ['%s=%r' % (key, value)
20440 
      for key, value in self.__dict__.iteritems()]
20441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20442 
 
20443 
  def __eq__(self, other):
20444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20445 
 
20446 
  def __ne__(self, other):
20447 
    return not (self == other)
20448 
 
20449 
class getSettlementForPaymentId_result:
20450 
  """
20451 
  Attributes:
20452 
   - success
20453 
   - ex
20454 
  """
20455 
 
20456 
  thrift_spec = (
20457 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20459 
  )
20460 
 
20461 
  def __init__(self, success=None, ex=None,):
20462 
    self.success = success
20463 
    self.ex = ex
20464 
 
20465 
  def read(self, iprot):
20466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20468 
      return
20469 
    iprot.readStructBegin()
20470 
    while True:
20471 
      (fname, ftype, fid) = iprot.readFieldBegin()
20472 
      if ftype == TType.STOP:
20473 
        break
20474 
      if fid == 0:
20475 
        if ftype == TType.STRUCT:
20476 
          self.success = PaymentSettlement()
20477 
          self.success.read(iprot)
20478 
        else:
20479 
          iprot.skip(ftype)
20480 
      elif fid == 1:
20481 
        if ftype == TType.STRUCT:
20482 
          self.ex = TransactionServiceException()
20483 
          self.ex.read(iprot)
20484 
        else:
20485 
          iprot.skip(ftype)
20486 
      else:
20487 
        iprot.skip(ftype)
20488 
      iprot.readFieldEnd()
20489 
    iprot.readStructEnd()
20490 
 
20491 
  def write(self, oprot):
20492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20494 
      return
20495 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
20496 
    if self.success is not None:
20497 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20498 
      self.success.write(oprot)
20499 
      oprot.writeFieldEnd()
20500 
    if self.ex is not None:
20501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20502 
      self.ex.write(oprot)
20503 
      oprot.writeFieldEnd()
20504 
    oprot.writeFieldStop()
20505 
    oprot.writeStructEnd()
20506 
 
20507 
  def validate(self):
20508 
    return
20509 
 
20510 
 
20511 
  def __repr__(self):
20512 
    L = ['%s=%r' % (key, value)
20513 
      for key, value in self.__dict__.iteritems()]
20514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20515 
 
20516 
  def __eq__(self, other):
20517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20518 
 
20519 
  def __ne__(self, other):
20520 
    return not (self == other)
20521 
 
20522 
class getEBSSettlementSummaries_args:
20523 
 
20524 
  thrift_spec = (
20525 
  )
20526 
 
20527 
  def read(self, iprot):
20528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20530 
      return
20531 
    iprot.readStructBegin()
20532 
    while True:
20533 
      (fname, ftype, fid) = iprot.readFieldBegin()
20534 
      if ftype == TType.STOP:
20535 
        break
20536 
      else:
20537 
        iprot.skip(ftype)
20538 
      iprot.readFieldEnd()
20539 
    iprot.readStructEnd()
20540 
 
20541 
  def write(self, oprot):
20542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20544 
      return
20545 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20546 
    oprot.writeFieldStop()
20547 
    oprot.writeStructEnd()
20548 
 
20549 
  def validate(self):
20550 
    return
20551 
 
20552 
 
20553 
  def __repr__(self):
20554 
    L = ['%s=%r' % (key, value)
20555 
      for key, value in self.__dict__.iteritems()]
20556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20557 
 
20558 
  def __eq__(self, other):
20559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20560 
 
20561 
  def __ne__(self, other):
20562 
    return not (self == other)
20563 
 
20564 
class getEBSSettlementSummaries_result:
20565 
  """
20566 
  Attributes:
20567 
   - success
20568 
   - ex
20569 
  """
20570 
 
20571 
  thrift_spec = (
20572 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20574 
  )
20575 
 
20576 
  def __init__(self, success=None, ex=None,):
20577 
    self.success = success
20578 
    self.ex = ex
20579 
 
20580 
  def read(self, iprot):
20581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20583 
      return
20584 
    iprot.readStructBegin()
20585 
    while True:
20586 
      (fname, ftype, fid) = iprot.readFieldBegin()
20587 
      if ftype == TType.STOP:
20588 
        break
20589 
      if fid == 0:
20590 
        if ftype == TType.MAP:
20591 
          self.success = {}
4999 phani.kuma 20592 
          (_ktype456, _vtype457, _size455 ) = iprot.readMapBegin()
20593 
          for _i459 in xrange(_size455):
20594 
            _key460 = iprot.readI64();
20595 
            _val461 = iprot.readString();
20596 
            self.success[_key460] = _val461
4600 varun.gupt 20597 
          iprot.readMapEnd()
20598 
        else:
20599 
          iprot.skip(ftype)
20600 
      elif fid == 1:
20601 
        if ftype == TType.STRUCT:
20602 
          self.ex = TransactionServiceException()
20603 
          self.ex.read(iprot)
20604 
        else:
20605 
          iprot.skip(ftype)
20606 
      else:
20607 
        iprot.skip(ftype)
20608 
      iprot.readFieldEnd()
20609 
    iprot.readStructEnd()
20610 
 
20611 
  def write(self, oprot):
20612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20614 
      return
20615 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20616 
    if self.success is not None:
20617 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20618 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4999 phani.kuma 20619 
      for kiter462,viter463 in self.success.items():
20620 
        oprot.writeI64(kiter462)
20621 
        oprot.writeString(viter463)
4600 varun.gupt 20622 
      oprot.writeMapEnd()
20623 
      oprot.writeFieldEnd()
20624 
    if self.ex is not None:
20625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20626 
      self.ex.write(oprot)
20627 
      oprot.writeFieldEnd()
20628 
    oprot.writeFieldStop()
20629 
    oprot.writeStructEnd()
20630 
 
20631 
  def validate(self):
20632 
    return
20633 
 
20634 
 
20635 
  def __repr__(self):
20636 
    L = ['%s=%r' % (key, value)
20637 
      for key, value in self.__dict__.iteritems()]
20638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20639 
 
20640 
  def __eq__(self, other):
20641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20642 
 
20643 
  def __ne__(self, other):
20644 
    return not (self == other)
20645 
 
20646 
class markEBSSettlementUploaded_args:
20647 
  """
20648 
  Attributes:
20649 
   - settlementId
20650 
  """
20651 
 
20652 
  thrift_spec = (
20653 
    None, # 0
20654 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20655 
  )
20656 
 
20657 
  def __init__(self, settlementId=None,):
20658 
    self.settlementId = settlementId
20659 
 
20660 
  def read(self, iprot):
20661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20663 
      return
20664 
    iprot.readStructBegin()
20665 
    while True:
20666 
      (fname, ftype, fid) = iprot.readFieldBegin()
20667 
      if ftype == TType.STOP:
20668 
        break
20669 
      if fid == 1:
20670 
        if ftype == TType.I64:
20671 
          self.settlementId = iprot.readI64();
20672 
        else:
20673 
          iprot.skip(ftype)
20674 
      else:
20675 
        iprot.skip(ftype)
20676 
      iprot.readFieldEnd()
20677 
    iprot.readStructEnd()
20678 
 
20679 
  def write(self, oprot):
20680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20682 
      return
20683 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20684 
    if self.settlementId is not None:
20685 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20686 
      oprot.writeI64(self.settlementId)
20687 
      oprot.writeFieldEnd()
20688 
    oprot.writeFieldStop()
20689 
    oprot.writeStructEnd()
20690 
 
20691 
  def validate(self):
20692 
    return
20693 
 
20694 
 
20695 
  def __repr__(self):
20696 
    L = ['%s=%r' % (key, value)
20697 
      for key, value in self.__dict__.iteritems()]
20698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20699 
 
20700 
  def __eq__(self, other):
20701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20702 
 
20703 
  def __ne__(self, other):
20704 
    return not (self == other)
20705 
 
20706 
class markEBSSettlementUploaded_result:
20707 
  """
20708 
  Attributes:
20709 
   - ex
20710 
  """
20711 
 
20712 
  thrift_spec = (
20713 
    None, # 0
20714 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20715 
  )
20716 
 
20717 
  def __init__(self, ex=None,):
20718 
    self.ex = ex
20719 
 
20720 
  def read(self, iprot):
20721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20723 
      return
20724 
    iprot.readStructBegin()
20725 
    while True:
20726 
      (fname, ftype, fid) = iprot.readFieldBegin()
20727 
      if ftype == TType.STOP:
20728 
        break
20729 
      if fid == 1:
20730 
        if ftype == TType.STRUCT:
20731 
          self.ex = TransactionServiceException()
20732 
          self.ex.read(iprot)
20733 
        else:
20734 
          iprot.skip(ftype)
20735 
      else:
20736 
        iprot.skip(ftype)
20737 
      iprot.readFieldEnd()
20738 
    iprot.readStructEnd()
20739 
 
20740 
  def write(self, oprot):
20741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20743 
      return
20744 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20745 
    if self.ex is not None:
20746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20747 
      self.ex.write(oprot)
20748 
      oprot.writeFieldEnd()
20749 
    oprot.writeFieldStop()
20750 
    oprot.writeStructEnd()
20751 
 
20752 
  def validate(self):
20753 
    return
20754 
 
20755 
 
20756 
  def __repr__(self):
20757 
    L = ['%s=%r' % (key, value)
20758 
      for key, value in self.__dict__.iteritems()]
20759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20760 
 
20761 
  def __eq__(self, other):
20762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20763 
 
20764 
  def __ne__(self, other):
20765 
    return not (self == other)
20766 
 
20767 
class getEBSSettlementDate_args:
20768 
  """
20769 
  Attributes:
20770 
   - settlementId
20771 
  """
20772 
 
20773 
  thrift_spec = (
20774 
    None, # 0
20775 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20776 
  )
20777 
 
20778 
  def __init__(self, settlementId=None,):
20779 
    self.settlementId = settlementId
20780 
 
20781 
  def read(self, iprot):
20782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20784 
      return
20785 
    iprot.readStructBegin()
20786 
    while True:
20787 
      (fname, ftype, fid) = iprot.readFieldBegin()
20788 
      if ftype == TType.STOP:
20789 
        break
20790 
      if fid == 1:
20791 
        if ftype == TType.I64:
20792 
          self.settlementId = iprot.readI64();
20793 
        else:
20794 
          iprot.skip(ftype)
20795 
      else:
20796 
        iprot.skip(ftype)
20797 
      iprot.readFieldEnd()
20798 
    iprot.readStructEnd()
20799 
 
20800 
  def write(self, oprot):
20801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20803 
      return
20804 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20805 
    if self.settlementId is not None:
20806 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20807 
      oprot.writeI64(self.settlementId)
20808 
      oprot.writeFieldEnd()
20809 
    oprot.writeFieldStop()
20810 
    oprot.writeStructEnd()
20811 
 
20812 
  def validate(self):
20813 
    return
20814 
 
20815 
 
20816 
  def __repr__(self):
20817 
    L = ['%s=%r' % (key, value)
20818 
      for key, value in self.__dict__.iteritems()]
20819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20820 
 
20821 
  def __eq__(self, other):
20822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20823 
 
20824 
  def __ne__(self, other):
20825 
    return not (self == other)
20826 
 
20827 
class getEBSSettlementDate_result:
20828 
  """
20829 
  Attributes:
20830 
   - success
20831 
   - ex
20832 
  """
20833 
 
20834 
  thrift_spec = (
20835 
    (0, TType.I64, 'success', None, None, ), # 0
20836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20837 
  )
20838 
 
20839 
  def __init__(self, success=None, ex=None,):
20840 
    self.success = success
20841 
    self.ex = ex
20842 
 
20843 
  def read(self, iprot):
20844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20846 
      return
20847 
    iprot.readStructBegin()
20848 
    while True:
20849 
      (fname, ftype, fid) = iprot.readFieldBegin()
20850 
      if ftype == TType.STOP:
20851 
        break
20852 
      if fid == 0:
20853 
        if ftype == TType.I64:
20854 
          self.success = iprot.readI64();
20855 
        else:
20856 
          iprot.skip(ftype)
20857 
      elif fid == 1:
20858 
        if ftype == TType.STRUCT:
20859 
          self.ex = TransactionServiceException()
20860 
          self.ex.read(iprot)
20861 
        else:
20862 
          iprot.skip(ftype)
20863 
      else:
20864 
        iprot.skip(ftype)
20865 
      iprot.readFieldEnd()
20866 
    iprot.readStructEnd()
20867 
 
20868 
  def write(self, oprot):
20869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20871 
      return
20872 
    oprot.writeStructBegin('getEBSSettlementDate_result')
20873 
    if self.success is not None:
20874 
      oprot.writeFieldBegin('success', TType.I64, 0)
20875 
      oprot.writeI64(self.success)
20876 
      oprot.writeFieldEnd()
20877 
    if self.ex is not None:
20878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20879 
      self.ex.write(oprot)
20880 
      oprot.writeFieldEnd()
20881 
    oprot.writeFieldStop()
20882 
    oprot.writeStructEnd()
20883 
 
20884 
  def validate(self):
20885 
    return
20886 
 
20887 
 
20888 
  def __repr__(self):
20889 
    L = ['%s=%r' % (key, value)
20890 
      for key, value in self.__dict__.iteritems()]
20891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20892 
 
20893 
  def __eq__(self, other):
20894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20895 
 
20896 
  def __ne__(self, other):
20897 
    return not (self == other)
4715 varun.gupt 20898 
 
20899 
class getSettlementsByDate_args:
20900 
  """
20901 
  Attributes:
20902 
   - settlementDateFrom
20903 
   - settlementDateTo
20904 
   - isRefund
20905 
  """
20906 
 
20907 
  thrift_spec = (
20908 
    None, # 0
20909 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
20910 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
20911 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
20912 
  )
20913 
 
20914 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
20915 
    self.settlementDateFrom = settlementDateFrom
20916 
    self.settlementDateTo = settlementDateTo
20917 
    self.isRefund = isRefund
20918 
 
20919 
  def read(self, iprot):
20920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20922 
      return
20923 
    iprot.readStructBegin()
20924 
    while True:
20925 
      (fname, ftype, fid) = iprot.readFieldBegin()
20926 
      if ftype == TType.STOP:
20927 
        break
20928 
      if fid == 1:
20929 
        if ftype == TType.I64:
20930 
          self.settlementDateFrom = iprot.readI64();
20931 
        else:
20932 
          iprot.skip(ftype)
20933 
      elif fid == 2:
20934 
        if ftype == TType.I64:
20935 
          self.settlementDateTo = iprot.readI64();
20936 
        else:
20937 
          iprot.skip(ftype)
20938 
      elif fid == 3:
20939 
        if ftype == TType.BOOL:
20940 
          self.isRefund = iprot.readBool();
20941 
        else:
20942 
          iprot.skip(ftype)
20943 
      else:
20944 
        iprot.skip(ftype)
20945 
      iprot.readFieldEnd()
20946 
    iprot.readStructEnd()
20947 
 
20948 
  def write(self, oprot):
20949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20951 
      return
20952 
    oprot.writeStructBegin('getSettlementsByDate_args')
20953 
    if self.settlementDateFrom is not None:
20954 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
20955 
      oprot.writeI64(self.settlementDateFrom)
20956 
      oprot.writeFieldEnd()
20957 
    if self.settlementDateTo is not None:
20958 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
20959 
      oprot.writeI64(self.settlementDateTo)
20960 
      oprot.writeFieldEnd()
20961 
    if self.isRefund is not None:
20962 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
20963 
      oprot.writeBool(self.isRefund)
20964 
      oprot.writeFieldEnd()
20965 
    oprot.writeFieldStop()
20966 
    oprot.writeStructEnd()
20967 
 
20968 
  def validate(self):
20969 
    return
20970 
 
20971 
 
20972 
  def __repr__(self):
20973 
    L = ['%s=%r' % (key, value)
20974 
      for key, value in self.__dict__.iteritems()]
20975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20976 
 
20977 
  def __eq__(self, other):
20978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20979 
 
20980 
  def __ne__(self, other):
20981 
    return not (self == other)
20982 
 
20983 
class getSettlementsByDate_result:
20984 
  """
20985 
  Attributes:
20986 
   - success
20987 
   - ex
20988 
  """
20989 
 
20990 
  thrift_spec = (
20991 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
20992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20993 
  )
20994 
 
20995 
  def __init__(self, success=None, ex=None,):
20996 
    self.success = success
20997 
    self.ex = ex
20998 
 
20999 
  def read(self, iprot):
21000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21002 
      return
21003 
    iprot.readStructBegin()
21004 
    while True:
21005 
      (fname, ftype, fid) = iprot.readFieldBegin()
21006 
      if ftype == TType.STOP:
21007 
        break
21008 
      if fid == 0:
21009 
        if ftype == TType.LIST:
21010 
          self.success = []
4999 phani.kuma 21011 
          (_etype467, _size464) = iprot.readListBegin()
21012 
          for _i468 in xrange(_size464):
21013 
            _elem469 = PaymentSettlement()
21014 
            _elem469.read(iprot)
21015 
            self.success.append(_elem469)
4715 varun.gupt 21016 
          iprot.readListEnd()
21017 
        else:
21018 
          iprot.skip(ftype)
21019 
      elif fid == 1:
21020 
        if ftype == TType.STRUCT:
21021 
          self.ex = TransactionServiceException()
21022 
          self.ex.read(iprot)
21023 
        else:
21024 
          iprot.skip(ftype)
21025 
      else:
21026 
        iprot.skip(ftype)
21027 
      iprot.readFieldEnd()
21028 
    iprot.readStructEnd()
21029 
 
21030 
  def write(self, oprot):
21031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21033 
      return
21034 
    oprot.writeStructBegin('getSettlementsByDate_result')
21035 
    if self.success is not None:
21036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21037 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 21038 
      for iter470 in self.success:
21039 
        iter470.write(oprot)
4715 varun.gupt 21040 
      oprot.writeListEnd()
21041 
      oprot.writeFieldEnd()
21042 
    if self.ex is not None:
21043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21044 
      self.ex.write(oprot)
21045 
      oprot.writeFieldEnd()
21046 
    oprot.writeFieldStop()
21047 
    oprot.writeStructEnd()
21048 
 
21049 
  def validate(self):
21050 
    return
21051 
 
21052 
 
21053 
  def __repr__(self):
21054 
    L = ['%s=%r' % (key, value)
21055 
      for key, value in self.__dict__.iteritems()]
21056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21057 
 
21058 
  def __eq__(self, other):
21059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21060 
 
21061 
  def __ne__(self, other):
21062 
    return not (self == other)
21063 
 
21064 
class getReshippedOrderIds_args:
21065 
  """
21066 
  Attributes:
21067 
   - orderIds
21068 
  """
21069 
 
21070 
  thrift_spec = (
21071 
    None, # 0
21072 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21073 
  )
21074 
 
21075 
  def __init__(self, orderIds=None,):
21076 
    self.orderIds = orderIds
21077 
 
21078 
  def read(self, iprot):
21079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21081 
      return
21082 
    iprot.readStructBegin()
21083 
    while True:
21084 
      (fname, ftype, fid) = iprot.readFieldBegin()
21085 
      if ftype == TType.STOP:
21086 
        break
21087 
      if fid == 1:
21088 
        if ftype == TType.LIST:
21089 
          self.orderIds = []
4999 phani.kuma 21090 
          (_etype474, _size471) = iprot.readListBegin()
21091 
          for _i475 in xrange(_size471):
21092 
            _elem476 = iprot.readI64();
21093 
            self.orderIds.append(_elem476)
4715 varun.gupt 21094 
          iprot.readListEnd()
21095 
        else:
21096 
          iprot.skip(ftype)
21097 
      else:
21098 
        iprot.skip(ftype)
21099 
      iprot.readFieldEnd()
21100 
    iprot.readStructEnd()
21101 
 
21102 
  def write(self, oprot):
21103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21105 
      return
21106 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21107 
    if self.orderIds is not None:
21108 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21109 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4999 phani.kuma 21110 
      for iter477 in self.orderIds:
21111 
        oprot.writeI64(iter477)
4715 varun.gupt 21112 
      oprot.writeListEnd()
21113 
      oprot.writeFieldEnd()
21114 
    oprot.writeFieldStop()
21115 
    oprot.writeStructEnd()
21116 
 
21117 
  def validate(self):
21118 
    return
21119 
 
21120 
 
21121 
  def __repr__(self):
21122 
    L = ['%s=%r' % (key, value)
21123 
      for key, value in self.__dict__.iteritems()]
21124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21125 
 
21126 
  def __eq__(self, other):
21127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21128 
 
21129 
  def __ne__(self, other):
21130 
    return not (self == other)
21131 
 
21132 
class getReshippedOrderIds_result:
21133 
  """
21134 
  Attributes:
21135 
   - success
21136 
   - ex
21137 
  """
21138 
 
21139 
  thrift_spec = (
21140 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21142 
  )
21143 
 
21144 
  def __init__(self, success=None, ex=None,):
21145 
    self.success = success
21146 
    self.ex = ex
21147 
 
21148 
  def read(self, iprot):
21149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21151 
      return
21152 
    iprot.readStructBegin()
21153 
    while True:
21154 
      (fname, ftype, fid) = iprot.readFieldBegin()
21155 
      if ftype == TType.STOP:
21156 
        break
21157 
      if fid == 0:
21158 
        if ftype == TType.LIST:
21159 
          self.success = []
4999 phani.kuma 21160 
          (_etype481, _size478) = iprot.readListBegin()
21161 
          for _i482 in xrange(_size478):
21162 
            _elem483 = iprot.readI64();
21163 
            self.success.append(_elem483)
4715 varun.gupt 21164 
          iprot.readListEnd()
21165 
        else:
21166 
          iprot.skip(ftype)
21167 
      elif fid == 1:
21168 
        if ftype == TType.STRUCT:
21169 
          self.ex = TransactionServiceException()
21170 
          self.ex.read(iprot)
21171 
        else:
21172 
          iprot.skip(ftype)
21173 
      else:
21174 
        iprot.skip(ftype)
21175 
      iprot.readFieldEnd()
21176 
    iprot.readStructEnd()
21177 
 
21178 
  def write(self, oprot):
21179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21181 
      return
21182 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21183 
    if self.success is not None:
21184 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21185 
      oprot.writeListBegin(TType.I64, len(self.success))
4999 phani.kuma 21186 
      for iter484 in self.success:
21187 
        oprot.writeI64(iter484)
4715 varun.gupt 21188 
      oprot.writeListEnd()
21189 
      oprot.writeFieldEnd()
21190 
    if self.ex is not None:
21191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21192 
      self.ex.write(oprot)
21193 
      oprot.writeFieldEnd()
21194 
    oprot.writeFieldStop()
21195 
    oprot.writeStructEnd()
21196 
 
21197 
  def validate(self):
21198 
    return
21199 
 
21200 
 
21201 
  def __repr__(self):
21202 
    L = ['%s=%r' % (key, value)
21203 
      for key, value in self.__dict__.iteritems()]
21204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21205 
 
21206 
  def __eq__(self, other):
21207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21208 
 
21209 
  def __ne__(self, other):
21210 
    return not (self == other)
4757 mandeep.dh 21211 
 
21212 
class updateOrdersAsPORaised_args:
21213 
  """
21214 
  Attributes:
21215 
   - itemIdQuantityMap
21216 
   - purchaseOrderId
21217 
   - warehouseId
21218 
  """
21219 
 
21220 
  thrift_spec = (
21221 
    None, # 0
21222 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21223 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21224 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21225 
  )
21226 
 
21227 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21228 
    self.itemIdQuantityMap = itemIdQuantityMap
21229 
    self.purchaseOrderId = purchaseOrderId
21230 
    self.warehouseId = warehouseId
21231 
 
21232 
  def read(self, iprot):
21233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21235 
      return
21236 
    iprot.readStructBegin()
21237 
    while True:
21238 
      (fname, ftype, fid) = iprot.readFieldBegin()
21239 
      if ftype == TType.STOP:
21240 
        break
21241 
      if fid == 1:
21242 
        if ftype == TType.MAP:
21243 
          self.itemIdQuantityMap = {}
4999 phani.kuma 21244 
          (_ktype486, _vtype487, _size485 ) = iprot.readMapBegin()
21245 
          for _i489 in xrange(_size485):
21246 
            _key490 = iprot.readI64();
21247 
            _val491 = iprot.readI64();
21248 
            self.itemIdQuantityMap[_key490] = _val491
4757 mandeep.dh 21249 
          iprot.readMapEnd()
21250 
        else:
21251 
          iprot.skip(ftype)
21252 
      elif fid == 2:
21253 
        if ftype == TType.I64:
21254 
          self.purchaseOrderId = iprot.readI64();
21255 
        else:
21256 
          iprot.skip(ftype)
21257 
      elif fid == 3:
21258 
        if ftype == TType.I64:
21259 
          self.warehouseId = iprot.readI64();
21260 
        else:
21261 
          iprot.skip(ftype)
21262 
      else:
21263 
        iprot.skip(ftype)
21264 
      iprot.readFieldEnd()
21265 
    iprot.readStructEnd()
21266 
 
21267 
  def write(self, oprot):
21268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21270 
      return
21271 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21272 
    if self.itemIdQuantityMap is not None:
21273 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21274 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4999 phani.kuma 21275 
      for kiter492,viter493 in self.itemIdQuantityMap.items():
21276 
        oprot.writeI64(kiter492)
21277 
        oprot.writeI64(viter493)
4757 mandeep.dh 21278 
      oprot.writeMapEnd()
21279 
      oprot.writeFieldEnd()
21280 
    if self.purchaseOrderId is not None:
21281 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21282 
      oprot.writeI64(self.purchaseOrderId)
21283 
      oprot.writeFieldEnd()
21284 
    if self.warehouseId is not None:
21285 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21286 
      oprot.writeI64(self.warehouseId)
21287 
      oprot.writeFieldEnd()
21288 
    oprot.writeFieldStop()
21289 
    oprot.writeStructEnd()
21290 
 
21291 
  def validate(self):
21292 
    return
21293 
 
21294 
 
21295 
  def __repr__(self):
21296 
    L = ['%s=%r' % (key, value)
21297 
      for key, value in self.__dict__.iteritems()]
21298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21299 
 
21300 
  def __eq__(self, other):
21301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21302 
 
21303 
  def __ne__(self, other):
21304 
    return not (self == other)
21305 
 
21306 
class updateOrdersAsPORaised_result:
21307 
  """
21308 
  Attributes:
21309 
   - ex
21310 
  """
21311 
 
21312 
  thrift_spec = (
21313 
    None, # 0
21314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21315 
  )
21316 
 
21317 
  def __init__(self, ex=None,):
21318 
    self.ex = ex
21319 
 
21320 
  def read(self, iprot):
21321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21323 
      return
21324 
    iprot.readStructBegin()
21325 
    while True:
21326 
      (fname, ftype, fid) = iprot.readFieldBegin()
21327 
      if ftype == TType.STOP:
21328 
        break
21329 
      if fid == 1:
21330 
        if ftype == TType.STRUCT:
21331 
          self.ex = TransactionServiceException()
21332 
          self.ex.read(iprot)
21333 
        else:
21334 
          iprot.skip(ftype)
21335 
      else:
21336 
        iprot.skip(ftype)
21337 
      iprot.readFieldEnd()
21338 
    iprot.readStructEnd()
21339 
 
21340 
  def write(self, oprot):
21341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21343 
      return
21344 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21345 
    if self.ex is not None:
21346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21347 
      self.ex.write(oprot)
21348 
      oprot.writeFieldEnd()
21349 
    oprot.writeFieldStop()
21350 
    oprot.writeStructEnd()
21351 
 
21352 
  def validate(self):
21353 
    return
21354 
 
21355 
 
21356 
  def __repr__(self):
21357 
    L = ['%s=%r' % (key, value)
21358 
      for key, value in self.__dict__.iteritems()]
21359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21360 
 
21361 
  def __eq__(self, other):
21362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21363 
 
21364 
  def __ne__(self, other):
21365 
    return not (self == other)
4875 varun.gupt 21366 
 
21367 
class getOrdersWhereVendorNotPaid_args:
21368 
  """
21369 
  Attributes:
21370 
   - vendorId
21371 
  """
21372 
 
21373 
  thrift_spec = (
21374 
    None, # 0
21375 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21376 
  )
21377 
 
21378 
  def __init__(self, vendorId=None,):
21379 
    self.vendorId = vendorId
21380 
 
21381 
  def read(self, iprot):
21382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21384 
      return
21385 
    iprot.readStructBegin()
21386 
    while True:
21387 
      (fname, ftype, fid) = iprot.readFieldBegin()
21388 
      if ftype == TType.STOP:
21389 
        break
21390 
      if fid == 1:
21391 
        if ftype == TType.I64:
21392 
          self.vendorId = iprot.readI64();
21393 
        else:
21394 
          iprot.skip(ftype)
21395 
      else:
21396 
        iprot.skip(ftype)
21397 
      iprot.readFieldEnd()
21398 
    iprot.readStructEnd()
21399 
 
21400 
  def write(self, oprot):
21401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21403 
      return
21404 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21405 
    if self.vendorId is not None:
21406 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21407 
      oprot.writeI64(self.vendorId)
21408 
      oprot.writeFieldEnd()
21409 
    oprot.writeFieldStop()
21410 
    oprot.writeStructEnd()
21411 
 
21412 
  def validate(self):
21413 
    return
21414 
 
21415 
 
21416 
  def __repr__(self):
21417 
    L = ['%s=%r' % (key, value)
21418 
      for key, value in self.__dict__.iteritems()]
21419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21420 
 
21421 
  def __eq__(self, other):
21422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21423 
 
21424 
  def __ne__(self, other):
21425 
    return not (self == other)
21426 
 
21427 
class getOrdersWhereVendorNotPaid_result:
21428 
  """
21429 
  Attributes:
21430 
   - success
21431 
   - ex
21432 
  """
21433 
 
21434 
  thrift_spec = (
21435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21437 
  )
21438 
 
21439 
  def __init__(self, success=None, ex=None,):
21440 
    self.success = success
21441 
    self.ex = ex
21442 
 
21443 
  def read(self, iprot):
21444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21446 
      return
21447 
    iprot.readStructBegin()
21448 
    while True:
21449 
      (fname, ftype, fid) = iprot.readFieldBegin()
21450 
      if ftype == TType.STOP:
21451 
        break
21452 
      if fid == 0:
21453 
        if ftype == TType.LIST:
21454 
          self.success = []
4999 phani.kuma 21455 
          (_etype497, _size494) = iprot.readListBegin()
21456 
          for _i498 in xrange(_size494):
21457 
            _elem499 = Order()
21458 
            _elem499.read(iprot)
21459 
            self.success.append(_elem499)
4875 varun.gupt 21460 
          iprot.readListEnd()
21461 
        else:
21462 
          iprot.skip(ftype)
21463 
      elif fid == 1:
21464 
        if ftype == TType.STRUCT:
21465 
          self.ex = TransactionServiceException()
21466 
          self.ex.read(iprot)
21467 
        else:
21468 
          iprot.skip(ftype)
21469 
      else:
21470 
        iprot.skip(ftype)
21471 
      iprot.readFieldEnd()
21472 
    iprot.readStructEnd()
21473 
 
21474 
  def write(self, oprot):
21475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21477 
      return
21478 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21479 
    if self.success is not None:
21480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4999 phani.kuma 21482 
      for iter500 in self.success:
21483 
        iter500.write(oprot)
4875 varun.gupt 21484 
      oprot.writeListEnd()
21485 
      oprot.writeFieldEnd()
21486 
    if self.ex is not None:
21487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21488 
      self.ex.write(oprot)
21489 
      oprot.writeFieldEnd()
21490 
    oprot.writeFieldStop()
21491 
    oprot.writeStructEnd()
21492 
 
21493 
  def validate(self):
21494 
    return
21495 
 
21496 
 
21497 
  def __repr__(self):
21498 
    L = ['%s=%r' % (key, value)
21499 
      for key, value in self.__dict__.iteritems()]
21500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21501 
 
21502 
  def __eq__(self, other):
21503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21504 
 
21505 
  def __ne__(self, other):
21506 
    return not (self == other)